Take implicit parameters into account for is-as-specific computations

Number of implicit parameters is applied as a final tie break, if
two alternatives would be otherwise equally specific.

I tried to roll them into type specificity first, but this fails
the dotc bootstrap where we have:

     def name(implicit ctx: Context): Name  in class Denotation

     val name: Name                         in subclass SymDenotation

The `val name` wins, since it is defined in a subclass and the result types
are the same. If we let the type `(implicit ctx: Context): Name` win over
`Name` this would be ambiguous instead.

Author: odersky

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

@@ -1191,6 +1191,10 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
    *
    *   - A1's owner derives from A2's owner.
    *   - A1's type is more specific than A2's type.
+   *
+   *  If that tournament yields a draw, a tiebreak is applied where
+   *  an alternative that takes more implicit parameters wins over one
+   *  that takes fewer.
    */
   def compare(alt1: TermRef, alt2: TermRef)(implicit ctx: Context): Int = track("compare") { trace(i"compare($alt1, $alt2)", overload) {
 
@@ -1290,12 +1294,16 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
         (flip(tp1) relaxed_<:< flip(tp2)) || viewExists(tp1, tp2)
       }
 
+    // # skipped implicit parameters in tp1  -  # skipped implicit parameters in tp2
+    var implicitBalance: Int = 0
+
     /** Drop any implicit parameter section */
-    def stripImplicit(tp: Type): Type = tp match {
+    def stripImplicit(tp: Type, weight: Int): Type = tp match {
       case mt: MethodType if mt.isImplicitMethod =>
+        implicitBalance += mt.paramInfos.length * weight
         resultTypeApprox(mt)
       case pt: PolyType =>
-        pt.derivedLambdaType(pt.paramNames, pt.paramInfos, stripImplicit(pt.resultType))
+        pt.derivedLambdaType(pt.paramNames, pt.paramInfos, stripImplicit(pt.resultType, weight))
       case _ =>
         tp
     }
@@ -1304,21 +1312,23 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
     val owner2 = if (alt2.symbol.exists) alt2.symbol.owner else NoSymbol
     val ownerScore = compareOwner(owner1, owner2)
 
-    val tp1 = stripImplicit(alt1.widen)
-    val tp2 = stripImplicit(alt2.widen)
+    val tp1 = stripImplicit(alt1.widen, -1)
+    val tp2 = stripImplicit(alt2.widen, +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 tieBreak = -implicitBalance.signum
+
     if (ownerScore == 1)
-      if (winsType1 || !winsType2) 1 else 0
+      if (winsType1 || !winsType2) 1 else tieBreak
     else if (ownerScore == -1)
-      if (winsType2 || !winsType1) -1 else 0
+      if (winsType2 || !winsType1) -1 else tieBreak
     else if (winsType1)
-      if (winsType2) 0 else 1
+      if (winsType2) tieBreak else 1
     else
-      if (winsType2) -1 else 0
+      if (winsType2) -1 else tieBreak
   }}
 
   def narrowMostSpecific(alts: List[TermRef])(implicit ctx: Context): List[TermRef] = track("narrowMostSpecific") {

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

@@ -81,4 +81,20 @@ affect implicits on the language level.
         def buzz(y: A) = ???
         buzz(1)   // error: ambiguous
 
+ 6. 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
+    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:
+
+    _Original version:_
+
+    > 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.
+
+    _Modified version:_
+
+    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.
+
 [//]: # todo: expand with precise rules

tests/neg/overloading-specifity.scala

@@ -0,0 +1,27 @@
+// Shows that overloading resolution does not test implicits to decide
+// applicability. A best alternative is picked first, and then implicits
+// are searched for this one.
+case class Show[T](val i: Int)
+class Show1[T](i: Int) extends Show[T](i)
+
+class Generic
+object Generic {
+  implicit val gen: Generic = new Generic
+  implicit def showGen[T](implicit gen: Generic): Show[T] = new Show[T](2)
+}
+
+object Test extends App {
+  trait Context
+  //implied ctx for Context
+
+  object a {
+    def foo[T](implicit gen: Generic): Show[T] = new Show[T](1)
+    def foo[T](implicit gen: Generic, ctx: Context): Show1[T] = new Show1[T](2)
+  }
+  object b {
+    def foo[T](implicit gen: Generic): Show[T] = new Show[T](1)
+    def foo[T]: Show[T] = new Show[T](2)
+  }
+
+  assert(a.foo[Int].i == 2) // error: no implicit argument of type Test.Context was found for parameter ctx
+}

tests/run/implicit-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] = new Show[Int](0)
+  implied fallback[T] for Show[T] = new Show[T](1)
+}
+
+class Generic
+object Generic {
+  implied gen for Generic = new Generic
+  implied showGen[T] given Generic for Show[T] = new Show[T](2)
+}
+
+object Contextual {
+  trait Context
+  implied ctx for Context
+  implied showGen[T] given Generic for Show[T] = new Show[T](2)
+  implied showGen[T] given Generic, Context for Show[T] = new 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)
+  }
+}

tests/run/overloading-specifity.scala

@@ -0,0 +1,27 @@
+// Shows that now implicit parameters act as a tie-breaker.
+// The alternative with more implicit parameters wins.
+case class Show[T](val i: Int)
+
+class Generic
+object Generic {
+  implicit val gen: Generic = new Generic
+  implicit def showGen[T](implicit gen: Generic): Show[T] = new Show[T](2)
+}
+
+object Test extends App {
+  trait Context
+  implied ctx for Context
+
+  object a {
+    def foo[T](implicit gen: Generic): Show[T] = new Show[T](1)
+    def foo[T](implicit gen: Generic, ctx: Context): Show[T] = new Show[T](2)
+  }
+  object b {
+    def foo[T](implicit gen: Generic): Show[T] = new Show[T](1)
+    def foo[T]: Show[T] = new Show[T](2)
+  }
+
+  assert(a.foo[Int].i == 2)
+  assert(b.foo[Int].i == 1)
+
+}