Synthesize implicits for product and sum mirrors

odersky · odersky · commit 62b3c6a7c51e · 2019-05-22T13:41:07.000+02:00
diff --git a/compiler/src/dotty/tools/dotc/core/Definitions.scala b/compiler/src/dotty/tools/dotc/core/Definitions.scala
@@ -688,7 +688,9 @@ class Definitions {
     lazy val ModuleSerializationProxyConstructor: TermSymbol =
       ModuleSerializationProxyClass.requiredMethod(nme.CONSTRUCTOR, List(ClassType(TypeBounds.empty)))
 
-  //lazy val MirrorType: TypeRef = ctx.requiredClassRef("scala.deriving.Mirror")
+  lazy val MirrorType: TypeRef = ctx.requiredClassRef("scala.deriving.Mirror")
+  def MirrorClass(implicit ctx: Context): ClassSymbol = MirrorType.symbol.asClass
+
   lazy val Mirror_ProductType: TypeRef = ctx.requiredClassRef("scala.deriving.Mirror.Product")
   def Mirror_ProductClass(implicit ctx: Context): ClassSymbol = Mirror_ProductType.symbol.asClass
 
@@ -709,7 +711,7 @@ class Definitions {
   def ShapeCaseClass(implicit ctx: Context): ClassSymbol  = ShapeCaseType.symbol.asClass
   lazy val ShapeCasesType: TypeRef             = ctx.requiredClassRef("scala.compiletime.Shape.Cases")
   def ShapeCasesClass(implicit ctx: Context): ClassSymbol = ShapeCasesType.symbol.asClass
-  lazy val MirrorType: TypeRef                 = ctx.requiredClassRef("scala.reflect.Mirror")
+  lazy val ReflectMirrorType: TypeRef          = ctx.requiredClassRef("scala.reflect.Mirror")
   lazy val GenericClassType: TypeRef           = ctx.requiredClassRef("scala.reflect.GenericClass")
 
   lazy val LanguageModuleRef: TermSymbol = ctx.requiredModule("scala.language")
diff --git a/compiler/src/dotty/tools/dotc/core/StdNames.scala b/compiler/src/dotty/tools/dotc/core/StdNames.scala
@@ -326,10 +326,13 @@ 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"
     val doubleHash: N           = "doubleHash"
+    val ElemLabels: N           = "ElemLabels"
+    val ElemTypes: N            = "ElemTypes"
     val ExistentialTypeTree: N  = "ExistentialTypeTree"
     val Flag : N                = "Flag"
     val floatHash: N            = "floatHash"
diff --git a/compiler/src/dotty/tools/dotc/transform/TypeUtils.scala b/compiler/src/dotty/tools/dotc/transform/TypeUtils.scala
@@ -7,6 +7,7 @@ import TypeErasure.ErasedValueType
 import Types._
 import Contexts._
 import Symbols._
+import Names.Name
 
 object TypeUtils {
   /** A decorator that provides methods on types
@@ -63,5 +64,7 @@ object TypeUtils {
         }
         extractAlias(lo)
     }
+
+    def refinedWith(name: Name, info: Type)(implicit ctx: Context) = RefinedType(self, name, info)
   }
 }
diff --git a/compiler/src/dotty/tools/dotc/typer/Deriving.scala b/compiler/src/dotty/tools/dotc/typer/Deriving.scala
@@ -372,7 +372,7 @@ trait Deriving { this: Typer =>
             TypeDef(shapeAlias)
           }
           val reflectMethod: DefDef = {
-            val meth = newMethod(nme.reflect, MethodType(clsArg :: Nil, defn.MirrorType)).entered
+            val meth = newMethod(nme.reflect, MethodType(clsArg :: Nil, defn.ReflectMirrorType)).entered
             def rhs(paramRef: Tree)(implicit ctx: Context): Tree = {
               def reflectCase(scrut: Tree, idx: Int, elems: List[Type]): Tree = {
                 val ordinal = Literal(Constant(idx))
@@ -401,7 +401,7 @@ trait Deriving { this: Typer =>
           }
 
           val reifyMethod: DefDef = {
-            val meth = newMethod(nme.reify, MethodType(defn.MirrorType :: Nil, clsArg)).entered
+            val meth = newMethod(nme.reify, MethodType(defn.ReflectMirrorType :: Nil, clsArg)).entered
             def rhs(paramRef: Tree)(implicit ctx: Context): Tree = {
               def reifyCase(caseType: Type, elems: List[Type]): Tree = caseType match {
                 case caseType: TermRef =>
diff --git a/compiler/src/dotty/tools/dotc/typer/Implicits.scala b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
@@ -27,6 +27,8 @@ import ErrorReporting._
 import reporting.diagnostic.Message
 import Inferencing.fullyDefinedType
 import Trees._
+import transform.SymUtils._
+import transform.TypeUtils._
 import Hashable._
 import util.{Property, SourceFile, NoSource}
 import config.Config
@@ -812,17 +814,103 @@ trait Implicits { self: Typer =>
           EmptyTree
       }
 
+  lazy val synthesizedProductMirror: SpecialHandler =
+    (formal: Type, span: Span) => implicit (ctx: Context) => {
+      formal.member(tpnme.MonoType).info match {
+        case monoAlias @ TypeAlias(monoType) =>
+          if (monoType.termSymbol.is(CaseVal)) {
+            val modul = monoType.termSymbol
+            val caseLabel = ConstantType(Constant(modul.name.toString))
+            val mirrorType = defn.Mirror_SingletonType
+              .refinedWith(tpnme.MonoType, monoAlias)
+              .refinedWith(tpnme.CaseLabel, TypeAlias(caseLabel))
+            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 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.ElemLabels, TypeAlias(TypeOps.nestedPairs(elemLabels)))
+            val modul = cls.linkedClass.sourceModule
+            assert(modul.is(Module))
+            ref(modul).withSpan(span).cast(mirrorType)
+          }
+          else EmptyTree
+        case _ => EmptyTree
+      }
+    }
+
+  lazy val synthesizedSumMirror: SpecialHandler =
+    (formal: Type, span: Span) => implicit (ctx: Context) =>
+      formal.member(tpnme.MonoType).info match {
+        case monoAlias @ TypeAlias(monoType) if monoType.classSymbol.isGenericSum =>
+          val cls = monoType.classSymbol
+          val elemTypes = cls.children.map {
+            case caseClass: ClassSymbol =>
+              assert(caseClass.is(Case))
+              if (caseClass.is(Module))
+                caseClass.sourceModule.termRef
+              else caseClass.primaryConstructor.info match {
+                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 tparams = poly.paramRefs
+                    val variances = caseClass.typeParams.map(_.paramVariance)
+                    val instanceTypes = (tparams, variances).zipped.map((tparam, variance) =>
+                      ctx.typeComparer.instanceType(tparam, fromBelow = variance < 0))
+                    resType.substParams(poly, instanceTypes)
+                  }
+                  instantiate(ctx.fresh.setExploreTyperState().setOwner(caseClass))
+                case _ =>
+                  caseClass.typeRef
+              }
+            case child => child.termRef
+          }
+          val mirrorType =
+            defn.Mirror_SumType
+              .refinedWith(tpnme.MonoType, monoAlias)
+              .refinedWith(tpnme.ElemTypes, TypeAlias(TypeOps.nestedPairs(elemTypes)))
+          var modul = cls.linkedClass.sourceModule
+          if (!modul.exists) ???
+          ref(modul).withSpan(span).cast(mirrorType)
+        case _ =>
+          EmptyTree
+      }
+
+  lazy val synthesizedMirror: SpecialHandler =
+    (formal: Type, span: Span) => implicit (ctx: Context) =>
+      formal.member(tpnme.MonoType).info match {
+        case monoAlias @ TypeAlias(monoType) =>
+          if (monoType.termSymbol.is(CaseVal) || monoType.classSymbol.isGenericProduct)
+            synthesizedProductMirror(formal, span)(ctx)
+          else
+            synthesizedSumMirror(formal, span)(ctx)
+      }
+
   private var mySpecialHandlers: SpecialHandlers = null
 
   private def specialHandlers(implicit ctx: Context) = {
     if (mySpecialHandlers == null)
       mySpecialHandlers = List(
-        defn.ClassTagClass -> synthesizedClassTag,
-        defn.QuotedTypeClass -> synthesizedTypeTag,
-        defn.GenericClass -> synthesizedGeneric,
+        defn.ClassTagClass        -> synthesizedClassTag,
+        defn.QuotedTypeClass      -> synthesizedTypeTag,
+        defn.GenericClass         -> synthesizedGeneric,
         defn.TastyReflectionClass -> synthesizedTastyContext,
-        defn.EqlClass -> synthesizedEq,
-        defn.ValueOfClass -> synthesizedValueOf
+        defn.EqlClass             -> synthesizedEq,
+        defn.ValueOfClass         -> synthesizedValueOf,
+        defn.Mirror_ProductClass  -> synthesizedProductMirror,
+        defn.Mirror_SumClass      -> synthesizedSumMirror,
+        defn.MirrorClass          -> synthesizedMirror
       )
     mySpecialHandlers
   }
@@ -836,7 +924,13 @@ trait Implicits { self: Typer =>
       case fail @ SearchFailure(failed) =>
         def trySpecialCases(handlers: SpecialHandlers): Tree = handlers match {
           case (cls, handler) :: rest =>
-            val base = formal.baseType(cls)
+            def baseWithRefinements(tp: Type): Type = tp.dealias match {
+              case tp @ RefinedType(parent, rname, rinfo) =>
+                tp.derivedRefinedType(baseWithRefinements(parent), rname, rinfo)
+              case _ =>
+                tp.baseType(cls)
+            }
+            val base = baseWithRefinements(formal)
             val result =
               if (base <:< formal) {
                 // With the subtype test we enforce that the searched type `formal` is of the right form
diff --git a/library/src/scala/deriving.scala b/library/src/scala/deriving.scala
@@ -39,6 +39,9 @@ object deriving {
 
     trait Singleton extends Product {
       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)
diff --git a/tests/run/deriving.check b/tests/run/deriving.check
@@ -0,0 +1,4 @@
+A(1,2)
+A(1,2)
+B
+1
diff --git a/tests/run/deriving.scala b/tests/run/deriving.scala
@@ -5,6 +5,23 @@ case class A(x: Int, y: Int) extends T
 case object B extends T
 
 object Test extends App {
+  import deriving.{Mirror, EmptyProduct}
 
   case class AA[X >: Null <: AnyRef](x: X, y: X, z: String)
+
+  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)
+  the[Mirror.Of[A]] match {
+    case m: Mirror.Product =>
+      println(m.fromProduct(A(1, 2)))
+  }
+  the[Mirror.Of[B.type]] match {
+    case m: Mirror.Product =>
+      println(m.fromProduct(EmptyProduct))
+  }
+  the[Mirror.Of[T]] match {
+    case m: Mirror.SumOf[T] =>
+      println(m.ordinal(B))
+  }
 }

Original file line number	Diff line number	Diff line change
`@@ -7,6 +7,7 @@ import TypeErasure.ErasedValueType`
`7`	`7`	`import Types._`
`8`	`8`	`import Contexts._`
`9`	`9`	`import Symbols._`
	`10`	`+import Names.Name`
`10`	`11`
`11`	`12`	`object TypeUtils {`
`12`	`13`	`/** A decorator that provides methods on types`
`@@ -63,5 +64,7 @@ object TypeUtils {`
`63`	`64`	`}`
`64`	`65`	`extractAlias(lo)`
`65`	`66`	`}`
	`67`	`+`
	`68`	`+ def refinedWith(name: Name, info: Type)(implicit ctx: Context) = RefinedType(self, name, info)`
`66`	`69`	`}`
`67`	`70`	`}`
-Original file line number
+Diff line change
@@ @@ -0,0 +1,4 @@ @@
 +A(1,2)
 +A(1,2)
 +B
 +1