Auto-generated derived typeclass instances

... except for Shaped, which is still a todo.

Author: odersky

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

@@ -398,6 +398,7 @@ object StdNames {
     val definitions: N          = "definitions"
     val delayedInit: N          = "delayedInit"
     val delayedInitArg: N       = "delayedInit$body"
+    val derived: N              = "derived"
     val derives: N              = "derives"
     val drop: N                 = "drop"
     val dynamics: N             = "dynamics"

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

@@ -117,13 +117,15 @@ trait Deriving { this: Typer =>
     /** Enter type class instance with given name and info in current scope, provided
       *  an instance woth the same name does not exist already.
       */
-    private def addDerivedInstance(clsName: Name, info: Type, reportErrors: Boolean) = {
+    private def addDerivedInstance(clsName: Name, info: Type, reportErrors: Boolean, implicitFlag: FlagSet = Implicit) = {
       val instanceName = s"derived$$$clsName".toTermName
       if (ctx.denotNamed(instanceName).exists) {
         if (reportErrors) ctx.error(i"duplicate typeclass derivation for $clsName")
       }
-      else
-        add(ctx.newSymbol(ctx.owner, instanceName, Synthetic | Method, info, coord = cls.pos))
+      else {
+        val implFlag = if (reportErrors) Implicit else EmptyFlags  // for now
+        add(ctx.newSymbol(ctx.owner, instanceName, Synthetic | Method | implFlag, info, coord = cls.pos.startPos))
+      }
     }
 
     /* Check derived type tree `derived` for the following well-formedness conditions:
@@ -176,16 +178,31 @@ trait Deriving { this: Typer =>
     def implementedClass(instance: Symbol) =
       instance.info.stripPoly.finalResultType.classSymbol
 
-    def typeclassInstance(sym: Symbol)(tparamRefs: List[Type])(paramRefss: List[List[tpd.Tree]]): tpd.Tree = {
-      val tparams = tparamRefs.map(_.typeSymbol.asType)
-      val params = if (paramRefss.isEmpty) Nil else paramRefss.head.map(_.symbol.asTerm)
-      val typeCls = implementedClass(sym)
-      tpd.ref(defn.Predef_undefinedR) // TODO: flesh out
-    }
+    private def typeclassInstance(sym: Symbol)(implicit ctx: Context) =
+      (tparamRefs: List[Type]) => (paramRefss: List[List[tpd.Tree]]) => {
+        val tparams = tparamRefs.map(_.typeSymbol.asType)
+        val params = if (paramRefss.isEmpty) Nil else paramRefss.head.map(_.symbol.asTerm)
+        tparams.foreach(ctx.enter)
+        params.foreach(ctx.enter)
+        def instantiated(info: Type): Type = info match {
+          case info: PolyType => instantiated(info.instantiate(tparamRefs))
+          case info: MethodType => info.instantiate(params.map(_.termRef))
+          case info => info
+        }
+        val resultType = instantiated(sym.info)
+        val typeCls = resultType.classSymbol
+        if (typeCls == defn.ShapedClass)
+          tpd.ref(defn.Predef_undefinedR) // TODO: flesh out
+        else {
+          val module = untpd.ref(typeCls.companionModule.termRef).withPos(sym.pos)
+          val rhs = untpd.Select(module, nme.derived)
+          typed(rhs, resultType)
+        }
+      }
 
     def syntheticDef(sym: Symbol): tpd.Tree =
       if (sym.isType) tpd.TypeDef(sym.asType)
-      else tpd.polyDefDef(sym.asTerm, typeclassInstance(sym))
+      else tpd.polyDefDef(sym.asTerm, typeclassInstance(sym)(ctx.fresh.setOwner(sym).setNewScope))
 
     def finalize(stat: tpd.TypeDef): tpd.Tree = {
       val templ @ Template(_, _, _, _) = stat.rhs

tests/run/typeclass-derivation3.scala

@@ -36,9 +36,9 @@ object datatypes {
     }
 
     // three clauses that could be generated from a `derives` clause
-    implicit def LstEq[T: Eq]: Eq[Lst[T]] = Eq.derived
-    implicit def LstPickler[T: Pickler]: Pickler[Lst[T]] = Pickler.derived
-    implicit def LstShow[T: Show]: Show[Lst[T]] = Show.derived
+    //implicit def LstEq[T: Eq]: Eq[Lst[T]] = Eq.derived
+    //implicit def LstPickler[T: Pickler]: Pickler[Lst[T]] = Pickler.derived
+    //implicit def LstShow[T: Show]: Show[Lst[T]] = Show.derived
   }
 
   // A simple product type
@@ -62,9 +62,9 @@ object datatypes {
     }
 
     // two clauses that could be generated from a `derives` clause
-    implicit def PairEq[T: Eq]: Eq[Pair[T]] = Eq.derived
-    implicit def PairPickler[T: Pickler]: Pickler[Pair[T]] = Pickler.derived
-    implicit def PairShow[T: Show]: Show[Pair[T]] = Show.derived
+    //implicit def PairEq[T: Eq]: Eq[Pair[T]] = Eq.derived
+    //implicit def PairPickler[T: Pickler]: Pickler[Pair[T]] = Pickler.derived
+    //implicit def PairShow[T: Show]: Show[Pair[T]] = Show.derived
   }
 
   sealed trait Either[+L, +R] extends Product derives Eq, Pickler, Show
@@ -95,9 +95,9 @@ object datatypes {
       def common = reflectedClass
     }
 
-    implicit def EitherEq[L: Eq, R: Eq]: Eq[Either[L, R]] = Eq.derived
-    implicit def EitherPickler[L: Pickler, R: Pickler]: Pickler[Either[L, R]] = Pickler.derived
-    implicit def EitherShow[L: Show, R: Show]: Show[Either[L, R]] = Show.derived
+    //implicit def EitherEq[L: Eq, R: Eq]: Eq[Either[L, R]] = Eq.derived
+    //implicit def EitherPickler[L: Pickler, R: Pickler]: Pickler[Either[L, R]] = Pickler.derived
+    //implicit def EitherShow[L: Show, R: Show]: Show[Either[L, R]] = Show.derived
   }
 }