Derive typeclasses with number of type parameters != 1

Author: odersky

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

@@ -161,33 +161,67 @@ trait Deriving { this: Typer =>
      *
      *      implicit def derived$D(implicit ev_1: D[T_1], ..., ev_n: D[T_n]): D[C[Ts]] = D.derived
      *
-     *  See test run/typeclass-derivation2 for examples that spell out what would be generated.
-     *  Note that the name of the derived method containd the name in the derives clause, not
+     *  See the body of this method for who to generalize this to typeclasses with more
+     *  or less than one type parameter.
+     *
+     *  See test run/typeclass-derivation2 and run/derive-multi
+     *  for examples that spell out what would be generated.
+     *
+     *  Note that the name of the derived method contains the name in the derives clause, not
      *  the underlying class name. This allows one to disambiguate derivations of type classes
      *  that have the same name but different prefixes through selective aliasing.
      */
     private def processDerivedInstance(derived: untpd.Tree): Unit = {
       val originalType = typedAheadType(derived, AnyTypeConstructorProto).tpe
       val underlyingType = underlyingClassRef(originalType)
       val derivedType = checkClassType(underlyingType, derived.sourcePos, traitReq = false, stablePrefixReq = true)
-      val nparams = derivedType.classSymbol.typeParams.length
+      val typeClass = derivedType.classSymbol
+      val nparams = typeClass.typeParams.length
       if (derivedType.isRef(defn.GenericClass))
         derivesGeneric = true
-      else if (nparams == 1) {
-        val typeClass = derivedType.classSymbol
-        val firstKindedParams = cls.typeParams.filterNot(_.info.isLambdaSub)
+      else {
+        // A matrix of all parameter combinations of current class parameters
+        // and derived typeclass parameters.
+        // Rows: parameters of current class
+        // Columns: parameters of typeclass
+
+        // Running example: typeclass: class TC[X, Y, Z], deriving class: class A[T, U]
+        // clsParamss =
+        //     T_X  T_Y  T_Z
+        //     U_X  U_Y  U_Z
+        val clsParamss: List[List[TypeSymbol]] = cls.typeParams.map { tparam =>
+          if (nparams == 0) Nil
+          else if (nparams == 1) tparam :: Nil
+          else typeClass.typeParams.map(tcparam =>
+            tparam.copy(name = s"${tparam.name}_${tcparam.name}".toTypeName)
+              .asInstanceOf[TypeSymbol])
+        }
+        val firstKindedParamss = clsParamss.filter {
+          case param :: _ => !param.info.isLambdaSub
+          case nil => false
+        }
+
+        // The types of the required evidence parameters. In the running example:
+        // TC[T_X, T_Y, T_Z], TC[U_X, U_Y, U_Z]
         val evidenceParamInfos =
-          for (param <- firstKindedParams) yield derivedType.appliedTo(param.typeRef)
-        val resultType = derivedType.appliedTo(cls.appliedRef)
+          for (row <- firstKindedParamss)
+          yield derivedType.appliedTo(row.map(_.typeRef))
+
+        // The class instances in the result type. Running example:
+        //   A[T_X, U_X], A[T_Y, U_Y], A[T_Z, U_Z]
+        val resultInstances =
+          for (n <- List.range(0, nparams))
+          yield cls.typeRef.appliedTo(clsParamss.map(row => row(n).typeRef))
+
+        // TC[A[T_X, U_X], A[T_Y, U_Y], A[T_Z, U_Z]]
+        val resultType = derivedType.appliedTo(resultInstances)
+
+        val clsParams: List[TypeSymbol] = clsParamss.flatten
         val instanceInfo =
-          if (cls.typeParams.isEmpty) ExprType(resultType)
-          else PolyType.fromParams(cls.typeParams, ImplicitMethodType(evidenceParamInfos, resultType))
+          if (clsParams.isEmpty) ExprType(resultType)
+          else PolyType.fromParams(clsParams, ImplicitMethodType(evidenceParamInfos, resultType))
         addDerivedInstance(originalType.typeSymbol.name, instanceInfo, derived.sourcePos, reportErrors = true)
       }
-      else
-        ctx.error(
-          i"derived class $derivedType should have one type paramater but has $nparams",
-          derived.sourcePos)
     }
 
     /** Add value corresponding to `val genericClass = new GenericClass(...)`

tests/run/derive-multi.check

@@ -0,0 +1,5 @@
+derived: A
+derived: B[One, Two]
+derived: B
+derived: B
+derived: B

tests/run/derive-multi.scala

@@ -0,0 +1,41 @@
+class A
+object A {
+  def derived: A = {
+    println("derived: A")
+    new A
+  }
+}
+
+class B[X, Y]
+object B {
+  def derived[X, Y]: B[X, Y] = {
+    println("derived: B")
+    new B[X, Y]
+  }
+}
+
+case class One() derives A, B
+case class Two() derives A, B
+
+implied for B[One, Two] {
+  println("derived: B[One, Two]")
+}
+
+enum Lst[T] derives A, B {
+  case Cons(x: T, xs: Lst[T])
+  case Nil()
+}
+
+case class Triple[S, T, U] derives A, B
+
+object Test1 {
+  import Lst._
+  implicitly[A]
+}
+
+object Test extends App {
+  Test1
+  implicitly[B[Lst[Lst[One]], Lst[Lst[Two]]]]
+  implicitly[B[Triple[One, One, One],
+               Triple[Two, Two, Two]]]
+}