Add deriving.Mirror infrastructure

Author: odersky

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

@@ -690,6 +690,16 @@ 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 Mirror_ProductType: TypeRef = ctx.requiredClassRef("scala.deriving.Mirror.Product")
+  def Mirror_ProductClass(implicit ctx: Context): ClassSymbol = Mirror_ProductType.symbol.asClass
+
+    lazy val Mirror_Product_fromProductR: TermRef = Mirror_ProductClass.requiredMethodRef(nme.fromProduct)
+    def Mirror_Product_fromProduct(implicit ctx: Context): Symbol = Mirror_Product_fromProductR.symbol
+
+  lazy val Mirror_SingletonType: TypeRef = ctx.requiredClassRef("scala.deriving.Mirror.Singleton")
+  def Mirror_SingletonClass(implicit ctx: Context): ClassSymbol = Mirror_SingletonType.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")

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

@@ -340,6 +340,7 @@ object StdNames {
     val longHash: N             = "longHash"
     val MatchCase: N            = "MatchCase"
     val Modifiers: N            = "Modifiers"
+    val MonoType: N             = "MonoType"
     val NestedAnnotArg: N       = "NestedAnnotArg"
     val NoFlags: N              = "NoFlags"
     val NoPrefix: N             = "NoPrefix"
@@ -432,6 +433,7 @@ object StdNames {
     val flagsFromBits : N       = "flagsFromBits"
     val flatMap: N              = "flatMap"
     val foreach: N              = "foreach"
+    val fromProduct: N          = "fromProduct"
     val genericArrayOps: N      = "genericArrayOps"
     val genericClass: N         = "genericClass"
     val get: N                  = "get"

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

@@ -447,7 +447,7 @@ class Namer { typer: Typer =>
     case _ => tree
   }
 
-  /** For all class definitions `stat` in `xstats`: If the companion class if
+  /** For all class definitions `stat` in `xstats`: If the companion class is
     * not also defined in `xstats`, invalidate it by setting its info to
     * NoType.
     */
@@ -702,7 +702,7 @@ class Namer { typer: Typer =>
       // If a top-level object or class has no companion in the current run, we
       // enter a dummy companion (`denot.isAbsent` returns true) in scope. This
       // ensures that we never use a companion from a previous run or from the
-      // classpath. See tests/pos/false-companion for an example where this
+      // class path. See tests/pos/false-companion for an example where this
       // matters.
       if (ctx.owner.is(PackageClass)) {
         for (cdef @ TypeDef(moduleName, _) <- moduleDef.values) {

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

@@ -160,9 +160,9 @@ trait TypeAssigner {
   private def toRepeated(tree: Tree, from: ClassSymbol)(implicit ctx: Context): Tree =
     Typed(tree, TypeTree(tree.tpe.widen.translateParameterized(from, defn.RepeatedParamClass)))
 
-   def seqToRepeated(tree: Tree)(implicit ctx: Context): Tree = toRepeated(tree, defn.SeqClass)
+  def seqToRepeated(tree: Tree)(implicit ctx: Context): Tree = toRepeated(tree, defn.SeqClass)
 
-   def arrayToRepeated(tree: Tree)(implicit ctx: Context): Tree = toRepeated(tree, defn.ArrayClass)
+  def arrayToRepeated(tree: Tree)(implicit ctx: Context): Tree = toRepeated(tree, defn.ArrayClass)
 
   /** A denotation exists really if it exists and does not point to a stale symbol. */
   final def reallyExists(denot: Denotation)(implicit ctx: Context): Boolean = try

library/src/scala/deriving.scala

@@ -0,0 +1,69 @@
+package scala
+
+object deriving {
+
+  /** Mirrors allows typelevel access to enums, case classes and objects, and their sealed parents.
+   */
+  sealed trait Mirror {
+
+    /** The mirrored *-type */
+    type MonoType
+  }
+
+  object Mirror {
+
+    /** The Mirror for a sum type */
+    trait Sum extends Mirror { self =>
+
+      type ElemTypes <: Tuple
+
+      /** The ordinal number of the case class of `x`. For enums, `ordinal(x) == x.ordinal` */
+      def ordinal(x: MonoType): Int
+    }
+
+    /** The Mirror for a product type */
+    trait Product extends Mirror {
+
+      /** The types of the elements */
+      type ElemTypes <: Tuple
+
+      /** The name of the whole product type */
+      type CaseLabel <: String
+
+      /** The names of the product elements */
+      type ElemLabels <: Tuple
+
+      /** Create a new instance of type `T` with elements taken from product `p`. */
+      def fromProduct(p: scala.Product): MonoType
+    }
+
+    trait Singleton extends Product with scala.Product {
+      type MonoType = this.type
+      def fromProduct(p: scala.Product) = this
+
+      def productElement(n: Int): Any = throw new IndexOutOfBoundsException(n.toString)
+      def productArity: Int = 0
+    }
+  }
+
+  type MirrorOf[T]        = Mirror { type MonoType = T }
+  type ProductMirrorOf[T] = Mirror.Product { type MonoType = T }
+  type SumMirrorOf[T]     = Mirror.Sum { type MonoType = T }
+
+  /** 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[AnyRef]())
+
+  /** Helper method to select a product element */
+  def productElement[T](x: Any, idx: Int) =
+    x.asInstanceOf[Product].productElement(idx).asInstanceOf[T]
+}

tests/run/typeclass-derivation2d.scala

@@ -14,11 +14,11 @@ object Deriving {
   sealed abstract class Mirror {
 
     /** The mirrored *-type */
-    type MonoType
+    type _MonoType
   }
-  type MirrorOf[T]        = Mirror { type MonoType = T }
-  type ProductMirrorOf[T] = Mirror.Product { type MonoType = T }
-  type SumMirrorOf[T]     = Mirror.Sum { type MonoType = T }
+  type MirrorOf[T]        = Mirror { type _MonoType = T }
+  type ProductMirrorOf[T] = Mirror.Product { type _MonoType = T }
+  type SumMirrorOf[T]     = Mirror.Sum { type _MonoType = T }
 
   object Mirror {
 
@@ -28,7 +28,7 @@ object Deriving {
       type ElemTypes <: Tuple
 
       /** The ordinal number of the case class of `x`. For enums, `ordinal(x) == x.ordinal` */
-      def ordinal(x: MonoType): Int
+      def ordinal(x: _MonoType): Int
     }
 
     /** The Mirror for a product type */
@@ -44,12 +44,12 @@ object Deriving {
       type ElemLabels <: 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): _MonoType
     }
 
     trait Singleton extends Product {
-      type MonoType = this.type
-      def fromProduct(p: scala.Product) = this
+      type _MonoType = this.type
+      def _fromProduct(p: scala.Product) = this
     }
   }
 
@@ -74,30 +74,30 @@ import Deriving._
 sealed trait Lst[+T] // derives Eq, Pickler, Show
 
 object Lst extends Mirror.Sum {
-  type MonoType = Lst[_]
+  type _MonoType = Lst[_]
 
   def ordinal(x: Lst[_]) = x match {
     case x: Cons[_] => 0
     case Nil => 1
   }
 
   implicit def mirror[T]: Mirror.Sum {
-    type MonoType = Lst[T]
+    type _MonoType = Lst[T]
     type ElemTypes = (Cons[T], Nil.type)
   } = this.asInstanceOf
 
   case class Cons[T](hd: T, tl: Lst[T]) extends Lst[T]
 
   object Cons extends Mirror.Product {
-    type MonoType = Lst[_]
+    type _MonoType = Lst[_]
 
     def apply[T](x: T, xs: Lst[T]): Lst[T] = new Cons(x, xs)
 
-    def fromProduct(p: Product): Cons[_] =
+    def _fromProduct(p: Product): Cons[_] =
       new Cons(productElement[Any](p, 0), productElement[Lst[Any]](p, 1))
 
     implicit def mirror[T]: Mirror.Product {
-      type MonoType = Cons[T]
+      type _MonoType = Cons[T]
       type ElemTypes = (T, Lst[T])
       type CaseLabel = "Cons"
       type ElemLabels = ("hd", "tl")
@@ -107,7 +107,7 @@ object Lst extends Mirror.Sum {
   case object Nil extends Lst[Nothing] with Mirror.Singleton {
 
     implicit def mirror: Mirror.Singleton {
-      type MonoType = Nil.type
+      type _MonoType = Nil.type
       type ElemTypes = Unit
       type CaseLabel = "Nil"
       type ElemLabels = Unit
@@ -125,13 +125,13 @@ object Lst extends Mirror.Sum {
 case class Pair[T](x: T, y: T) // derives Eq, Pickler, Show
 
 object Pair extends Mirror.Product {
-  type MonoType = Pair[_]
+  type _MonoType = Pair[_]
 
-  def fromProduct(p: Product): Pair[_] =
+  def _fromProduct(p: Product): Pair[_] =
     Pair(productElement[Any](p, 0), productElement[Any](p, 1))
 
   implicit def mirror[T]: Mirror.Product {
-    type MonoType = Pair[T]
+    type _MonoType = Pair[T]
     type ElemTypes = (T, T)
     type CaseLabel = "Pair"
     type ElemLabels = ("x", "y")
@@ -148,15 +148,15 @@ object Pair extends Mirror.Product {
 sealed trait Either[+L, +R] extends Product with Serializable // derives Eq, Pickler, Show
 
 object Either extends Mirror.Sum {
-  type MonoType = Either[_, _]
+  type _MonoType = Either[_, _]
 
   def ordinal(x: Either[_, _]) = x match {
     case x: Left[_] => 0
     case x: Right[_] => 1
   }
 
   implicit def mirror[L, R]: Mirror.Sum {
-    type MonoType = Either[L, R]
+    type _MonoType = Either[L, R]
     type ElemTypes = (Left[L], Right[R])
   } = this.asInstanceOf
 
@@ -169,21 +169,21 @@ case class Left[L](elem: L) extends Either[L, Nothing]
 case class Right[R](elem: R) extends Either[Nothing, R]
 
 object Left extends Mirror.Product {
-  type MonoType = Left[_]
-  def fromProduct(p: Product): Left[_] = Left(productElement[Any](p, 0))
+  type _MonoType = Left[_]
+  def _fromProduct(p: Product): Left[_] = Left(productElement[Any](p, 0))
   implicit def mirror[L]: Mirror.Product {
-    type MonoType = Left[L]
+    type _MonoType = Left[L]
     type ElemTypes = L *: Unit
     type CaseLabel = "Left"
     type ElemLabels = "x" *: Unit
   } = this.asInstanceOf
 }
 
 object Right extends Mirror.Product {
-  type MonoType = Right[_]
-  def fromProduct(p: Product): Right[_] = Right(productElement[Any](p, 0))
+  type _MonoType = Right[_]
+  def _fromProduct(p: Product): Right[_] = Right(productElement[Any](p, 0))
   implicit def mirror[R]: Mirror.Product {
-    type MonoType = Right[R]
+    type _MonoType = Right[R]
     type ElemTypes = R *: Unit
     type CaseLabel = "Right"
     type ElemLabels = "x" *: Unit
@@ -293,11 +293,11 @@ object Pickler {
   inline def unpickleCase[T, Elems <: Tuple](buf: mutable.ListBuffer[Int], m: ProductMirrorOf[T]): T = {
     inline val size = constValue[Tuple.Size[Elems]]
     inline if (size == 0)
-      m.fromProduct(EmptyProduct)
+      m._fromProduct(EmptyProduct)
     else {
       val elems = new ArrayProduct(size)
       unpickleElems[Elems](0)(buf, elems)
-      m.fromProduct(elems)
+      m._fromProduct(elems)
     }
   }