Handle derived typeclasses with non-trivial prefixes

Author: odersky

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

@@ -16,12 +16,6 @@ import Inferencing._
 import transform.TypeUtils._
 import transform.SymUtils._
 
-
-// TODOs:
-//  - handle case where there's no companion object
-//  - check that derived instances are stable
-//  - reference derived instances with correct prefix instead of just the symbol
-
 /** A typer mixin that implements typeclass derivation functionality */
 trait Deriving { this: Typer =>
 
@@ -131,14 +125,23 @@ trait Deriving { this: Typer =>
                           flags: FlagSet = EmptyFlags)(implicit ctx: Context): TermSymbol =
       newSymbol(name, info, pos, flags | Method).asTerm
 
+    /** A version of Type#underlyingClassRef that works also for higher-kinded types */
+    private def underlyingClassRef(tp: Type): Type = tp match {
+      case tp: TypeRef if tp.symbol.isClass => tp
+      case tp: TypeRef if tp.symbol.isAbstractType => NoType
+      case tp: TermRef => NoType
+      case tp: TypeProxy => underlyingClassRef(tp.underlying)
+      case _ => NoType
+    }
+
     /** Enter type class instance with given name and info in current scope, provided
      *  an instance with the same name does not exist already.
      *  @param  reportErrors  Report an error if an instance with the same name exists already
      */
     private def addDerivedInstance(clsName: Name, info: Type, pos: Position, reportErrors: Boolean) = {
       val instanceName = s"derived$$$clsName".toTermName
       if (ctx.denotNamed(instanceName).exists) {
-        if (reportErrors) ctx.error(i"duplicate typeclass derivation for $clsName")
+        if (reportErrors) ctx.error(i"duplicate typeclass derivation for $clsName", pos)
       }
       else add(newMethod(instanceName, info, pos, Implicit))
     }
@@ -162,8 +165,9 @@ trait Deriving { this: Typer =>
       * that have the same name but different prefixes through selective aliasing.
       */
     private def processDerivedInstance(derived: untpd.Tree): Unit = {
-      val uncheckedType = typedAheadType(derived, AnyTypeConstructorProto).tpe.dealias
-      val derivedType = checkClassType(uncheckedType, derived.pos, traitReq = false, stablePrefixReq = true)
+      val originalType = typedAheadType(derived, AnyTypeConstructorProto).tpe
+      val underlyingType = underlyingClassRef(originalType)
+      val derivedType = checkClassType(underlyingType, derived.pos, traitReq = false, stablePrefixReq = true)
       val nparams = derivedType.classSymbol.typeParams.length
       if (nparams == 1) {
         val typeClass = derivedType.classSymbol
@@ -174,7 +178,7 @@ trait Deriving { this: Typer =>
         val instanceInfo =
           if (cls.typeParams.isEmpty) ExprType(resultType)
           else PolyType.fromParams(cls.typeParams, ImplicitMethodType(evidenceParamInfos, resultType))
-        addDerivedInstance(derivedType.typeSymbol.name, instanceInfo, derived.pos, reportErrors = true)
+        addDerivedInstance(originalType.typeSymbol.name, instanceInfo, derived.pos, reportErrors = true)
       }
       else
         ctx.error(
@@ -377,14 +381,20 @@ trait Deriving { this: Typer =>
           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
+            case info => info.widenExpr
+          }
+          def classAndCompanionRef(tp: Type): (ClassSymbol, TermRef) = tp match {
+            case tp @ TypeRef(prefix, _) if tp.symbol.isClass =>
+              (tp.symbol.asClass, prefix.select(tp.symbol.companionModule).asInstanceOf[TermRef])
+            case tp: TypeProxy =>
+              classAndCompanionRef(tp.underlying)
           }
           val resultType = instantiated(sym.info)
-          val typeCls = resultType.classSymbol
+          val (typeCls, companionRef) = classAndCompanionRef(resultType)
           if (typeCls == defn.ShapedClass)
             shapedRHS(resultType)
           else {
-            val module = untpd.ref(typeCls.companionModule.termRef).withPos(sym.pos)
+            val module = untpd.ref(companionRef).withPos(sym.pos)
             val rhs = untpd.Select(module, nme.derived)
             typed(rhs, resultType)
           }

tests/neg/deriving-duplicate.scala

@@ -0,0 +1,21 @@
+object Test extends App {
+
+  class A {
+    class TC1[T] {
+    }
+    object TC1 {
+      def derived[T]: TC1[T] = new TC1[T]
+    }
+  }
+  class A2 {
+    class TC1[T] {
+    }
+    object TC1 {
+      def derived[T]: TC1[T] = new TC1[T]
+    }
+  }
+  val a = new A
+  val a2 = new A2
+
+  case class D() derives a.TC1, a2.TC1  // error: duplicate typeclass derivation
+}

tests/run/deriving-interesting-prefixes.check

@@ -0,0 +1,4 @@
+a.TC1
+b.TC2
+a.TC1
+a2.TC1

tests/run/deriving-interesting-prefixes.scala

@@ -0,0 +1,41 @@
+object Test extends App {
+
+  class A {
+    class TC1[T] {
+      def print() = println("a.TC1")
+    }
+    object TC1 {
+      def derived[T]: TC1[T] = new TC1[T]
+    }
+  }
+  class A2 {
+    class TC1[T] {
+      def print() = println("a2.TC1")
+    }
+    object TC1 {
+      def derived[T]: TC1[T] = new TC1[T]
+    }
+  }
+  class B {
+    class TC2[T] {
+      def print() = println("b.TC2")
+    }
+    object TC2 {
+      def derived[T]: TC2[T] = new TC2[T]
+    }
+  }
+  val a = new A
+  val a2 = new A2
+  val b = new B
+
+  case class C() derives a.TC1, b.TC2
+
+  implicitly[a.TC1[C]].print()
+  implicitly[b.TC2[C]].print()
+
+  type TC1a[T] = a2.TC1[T]
+  case class D() derives a.TC1, TC1a
+
+  implicitly[a.TC1[D]].print()
+  implicitly[a2.TC1[D]].print()
+}