Widen return type of implied wrappers

Author: odersky

compiler/src/dotty/tools/dotc/ast/Desugar.scala

@@ -650,9 +650,12 @@ object desugar {
                     // TODO: drop this once we do not silently insert empty class parameters anymore
           case paramss => paramss
         }
-        // implicit wrapper is typechecked in same scope as constructor, so
-        // we can reuse the constructor parameters; no derived params are needed.
-        DefDef(className.toTermName, constrTparams, defParamss, classTypeRef, creatorExpr)
+          // implicit wrapper is typechecked in same scope as constructor, so
+          // we can reuse the constructor parameters; no derived params are needed.
+        val resType =
+          if (mods.is(Implicit)) classTypeRef
+          else TypeTree() // infer by widening the rhs type, see widenImplied in Namer
+        DefDef(className.toTermName, constrTparams, defParamss, resType, creatorExpr)
           .withMods(companionMods | mods.flags.toTermFlags & ImplicitOrImplied | Synthetic | Final)
           .withSpan(cdef.span) :: Nil
       }

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

@@ -1227,7 +1227,27 @@ class Namer { typer: Typer =>
         }
       }
 
-      def cookedRhsType = deskolemize(dealiasIfUnit(widenRhs(rhsType)))
+      /** Widen type of implied def from the type of the implementing class
+       *  to the type for which it is implied. Example:
+       *
+       *      implied I[X] for T { ... }
+       *
+       *  This desugars to
+       *
+       *      class I[X] extends T { ... }
+       *      implied def I[X] = new I[X]
+       *
+       *  The inferred result type of the `def` should be `T`, not `I[X]`.
+       */
+      def widenImplied(tp: Type) =
+        if (sym.is(Implied))
+          tp.parents match {
+            case Nil => tp
+            case ps => ps.reduce(AndType(_, _))
+          }
+        else tp
+
+      def cookedRhsType = deskolemize(dealiasIfUnit(widenImplied(widenRhs(rhsType))))
       def lhsType = fullyDefinedType(cookedRhsType, "right-hand side", mdef.span)
       //if (sym.name.toString == "y") println(i"rhs = $rhsType, cooked = $cookedRhsType")
       if (inherited.exists) {

tests/run/implied-specifity.scala

@@ -0,0 +1,30 @@
+case class Show[T](val i: Int)
+object Show {
+  def apply[T](implicit st: Show[T]): Int = st.i
+
+  implied showInt for Show[Int](0)
+  implied fallback[T] for Show[T](1)
+}
+
+class Generic
+object Generic {
+  implied gen for Generic
+  implied showGen[T] given Generic for Show[T](2)
+}
+
+object Contextual {
+  trait Context
+  implied ctx for Context
+  implied showGen2[T] given Generic for Show[T](2)
+  implied showGen3[T] given Generic, Context for Show[T](3)
+}
+
+object Test extends App {
+  assert(Show[Int] == 0)
+  assert(Show[String] == 1)
+  assert(Show[Generic] == 2) // showGen beats fallback due to longer argument list
+
+  { import implied Contextual._
+    assert(Show[Generic] == 3)
+  }
+}