Refine disambiguation rules

If both alternatives have same weights and same number of implicit parameters,
treat them as normal (non-implicit) methods and try again.

Author: odersky

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

@@ -1297,7 +1297,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
     // # skipped implicit parameters in tp1  -  # skipped implicit parameters in tp2
     var implicitBalance: Int = 0
 
-    /** Widen the type of synthetic implied methods from the implementation class to the
+    /** Widen the result type of synthetic implied methods from the implementation class to the
      *  type that's implemented. Example
      *
      *      implied I[X] for T { ... }
@@ -1316,46 +1316,61 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
      *  objects, since these are anyway taken to be more specific than methods
      *  (by condition 3a above).
      */
-    def widenImplied(tp: Type, alt: TermRef): Type =
-      if (alt.symbol.is(SyntheticImpliedMethod))
-        tp.parents match {
-          case Nil => tp
-          case ps => ps.reduceLeft(AndType(_, _))
-        }
-      else tp
+    def widenImplied(tp: Type, alt: TermRef): Type = tp match {
+      case mt: MethodType if mt.isImplicitMethod =>
+        mt.derivedLambdaType(mt.paramNames, mt.paramInfos, widenImplied(mt.resultType, alt))
+      case pt: PolyType =>
+        pt.derivedLambdaType(pt.paramNames, pt.paramInfos, widenImplied(pt.resultType, alt))
+      case _ =>
+        if (alt.symbol.is(SyntheticImpliedMethod))
+          tp.parents match {
+            case Nil => tp
+            case ps => ps.reduceLeft(AndType(_, _))
+          }
+        else tp
+    }
 
     /** Drop any implicit parameter section */
-    def stripImplicit(tp: Type, alt: TermRef, weight: Int): Type = tp match {
+    def stripImplicit(tp: Type, weight: Int): Type = tp match {
       case mt: MethodType if mt.isImplicitMethod =>
         implicitBalance += mt.paramInfos.length * weight
-        widenImplied(resultTypeApprox(mt), alt)
+        resultTypeApprox(mt)
       case pt: PolyType =>
-        pt.derivedLambdaType(pt.paramNames, pt.paramInfos, stripImplicit(pt.resultType, alt, weight))
+        pt.derivedLambdaType(pt.paramNames, pt.paramInfos, stripImplicit(pt.resultType, weight))
       case _ =>
-        widenImplied(tp, alt)
+        tp
     }
 
     val owner1 = if (alt1.symbol.exists) alt1.symbol.owner else NoSymbol
     val owner2 = if (alt2.symbol.exists) alt2.symbol.owner else NoSymbol
     val ownerScore = compareOwner(owner1, owner2)
 
-    val tp1 = stripImplicit(alt1.widen, alt1, -1)
-    val tp2 = stripImplicit(alt2.widen, alt2, +1)
-    def winsType1  = isAsSpecific(alt1, tp1, alt2, tp2)
-    def winsType2  = isAsSpecific(alt2, tp2, alt1, tp1)
-
-    overload.println(i"compare($alt1, $alt2)? $tp1 $tp2 $ownerScore $winsType1 $winsType2")
+    def compareWithTypes(tp1: Type, tp2: Type) = {
+      def winsType1 = isAsSpecific(alt1, tp1, alt2, tp2)
+      def winsType2 = isAsSpecific(alt2, tp2, alt1, tp1)
+
+      overload.println(i"compare($alt1, $alt2)? $tp1 $tp2 $ownerScore $winsType1 $winsType2")
+      if (ownerScore == 1)
+	      if (winsType1 || !winsType2) 1 else 0
+	    else if (ownerScore == -1)
+	      if (winsType2 || !winsType1) -1 else 0
+	    else if (winsType1)
+	      if (winsType2) 0 else 1
+	    else
+        if (winsType2) -1 else 0
+    }
 
-    def tieBreak = -implicitBalance.signum
+    val fullType1 = widenImplied(alt1.widen, alt1)
+    val fullType2 = widenImplied(alt2.widen, alt2)
+    val strippedType1 = stripImplicit(fullType1, -1)
+    val strippedType2 = stripImplicit(fullType2, +1)
 
-    if (ownerScore == 1)
-      if (winsType1 || !winsType2) 1 else tieBreak
-    else if (ownerScore == -1)
-      if (winsType2 || !winsType1) -1 else tieBreak
-    else if (winsType1)
-      if (winsType2) tieBreak else 1
-    else
-      if (winsType2) -1 else tieBreak
+    val result = compareWithTypes(strippedType1, strippedType2)
+    if (result != 0) result
+    else if (implicitBalance != 0) -implicitBalance.signum
+    else if ((strippedType1 `ne` fullType1) || (strippedType2 `ne` fullType2))
+      compareWithTypes(fullType1, fullType2)
+    else 0
   }}
 
   def narrowMostSpecific(alts: List[TermRef])(implicit ctx: Context): List[TermRef] = track("narrowMostSpecific") {

docs/docs/reference/changed-features/implicit-resolution.md

@@ -99,9 +99,11 @@ affect implicits on the language level.
         buzz(1)   // error: ambiguous
 
  7. The rule for picking a _most specific_ alternative among a set of overloaded or implicit
-    alternatives is refined to take the number of inferable parameters into account. All else
+    alternatives is refined to take inferable parameters into account. All else
     being equal, an alternative that takes more inferable parameters is taken to be more specific
-    than an alternative that takes fewer. The following paragraph in the SLS is affected by this change:
+    than an alternative that takes fewer. If both alternatives take the same number of
+    inferable parameters, we try to choose between them as if they were methods with regular parameters.
+    The following paragraph in the SLS is affected by this change:
 
     _Original version:_
 
@@ -112,6 +114,9 @@ affect implicits on the language level.
     An alternative A is _more specific_ than an alternative B if
 
      - the relative weight of A over B is greater than the relative weight of B over A, or
-     - the relative weights are the same and A takes more inferable parameters than B.
+     - the relative weights are the same and A takes more inferable parameters than B, or
+     - the relative weights and the number of inferable parameters are the same and
+       A is more specific than B if all inferable parameters in either alternative are
+       replaced by regular parameters.
 
 [//]: # todo: expand with precise rules

tests/run/implicit-specifity-2.scala

@@ -0,0 +1,36 @@
+class Low
+object Low {
+  implicit val low: Low = new Low
+}
+class Medium extends Low
+object Medium {
+  implicit val medium: Medium = new Medium
+}
+class High extends Medium
+object High {
+  implicit val high: High = new High
+}
+
+class Foo[T](val i: Int)
+object Foo {
+  def apply[T](implicit fooT: Foo[T]): Int = fooT.i
+
+  implicit def foo[T](implicit priority: Low): Foo[T] = new Foo[T](0)
+  implicit def foobar[T](implicit priority: Low): Foo[Bar[T]] = new Foo[Bar[T]](1)
+  implicit def foobarbaz(implicit priority: Low): Foo[Bar[Baz]] = new Foo[Bar[Baz]](2)
+}
+class Bar[T]
+object Bar {
+  implicit def foobar[T](implicit priority: Medium): Foo[Bar[T]] = new Foo[Bar[T]](3)
+  implicit def foobarbaz(implicit priority: Medium): Foo[Bar[Baz]] = new Foo[Bar[Baz]](4)
+}
+class Baz
+object Baz {
+  implicit def baz(implicit priority: High): Foo[Bar[Baz]] = new Foo[Bar[Baz]](5)
+}
+
+object Test extends App {
+  assert(Foo[Int] == 0)
+  assert(Foo[Bar[Int]] == 3)
+  assert(Foo[Bar[Baz]] == 5)
+}

tests/run/implied-specifity-2.scala

@@ -0,0 +1,36 @@
+class Low
+object Low {
+  implied low for Low
+}
+class Medium extends Low
+object Medium {
+  implied medium for Medium
+}
+class High extends Medium
+object High {
+  implied high for High
+}
+
+class Foo[T](val i: Int)
+object Foo {
+  def apply[T] given (fooT: Foo[T]): Int = fooT.i
+
+  implied foo[T]    given Low for Foo[T](0)
+  implied foobar[T] given Low for Foo[Bar[T]](1)
+  implied foobarbaz given Low for Foo[Bar[Baz]](2)
+}
+class Bar[T]
+object Bar {
+  implied foobar[T] given Medium for Foo[Bar[T]](3)
+  implied foobarbaz given Medium for Foo[Bar[Baz]](4)
+}
+class Baz
+object Baz {
+  implied baz given High for Foo[Bar[Baz]](5)
+}
+
+object Test extends App {
+  assert(Foo[Int] == 0)
+  assert(Foo[Bar[Int]] == 3)
+  assert(Foo[Bar[Baz]] == 5)
+}