Another tweak to overloading resolution

After thinking even more about it, I now believe we should revise the rule. The idea of using implicits as a priority mechanism is so that we can write something like this:
```
  class LowPrio
  class MidPrio extends LowPrio
  class HighPrio extends MidPrio
  implied for LowPrio
  implied for MidPrio
  implied for HighPrio

  implied fallback given LowPrio for A
  implied standard given MidPrio for A
  implied specialized given HighPrio for A
```
(usually in different modules, of course). This is a good alternative to the previous priorization by owner subclassing since it places no demands on where implied instances are put and is stable under aliasing/forwarding.

But to do this reliably it should also work if some of the alternatives take additional implicit parameters. E.g.
```
  implied standard given MidPrio given B for A
```
The "more implicit parameters is better" rule would make standard of higher priority than specialized, which defeats the purpose.

Author: odersky

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

@@ -1344,9 +1344,6 @@ 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
-
     /** Widen the result type of synthetic implied methods from the implementation class to the
      *  type that's implemented. Example
      *
@@ -1383,7 +1380,6 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
     /** Drop any implicit parameter section */
     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, weight))
@@ -1416,14 +1412,12 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
     val strippedType2 = stripImplicit(fullType2, +1)
 
     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
+    if (result != 0) result
+    else if (strippedType1 eq fullType1)
+      if (strippedType2 eq fullType2) 0         // no implicits either side: its' a draw
+      else 1                                    // prefer 1st alternative with no implicits
+    else if (strippedType2 eq fullType2) -1     // prefer 2nd alternative with no implicits
+    else compareWithTypes(fullType1, fullType2) // continue by comparing implicits parameters
   }}
 
   def narrowMostSpecific(alts: List[TermRef])(implicit ctx: Context): List[TermRef] = track("narrowMostSpecific") {

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

@@ -114,9 +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 fewer 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
+     - the relative weights are the same, and A takes no implicit parameters but B does, or
+     - the relative weights are the same, both A and B take implicit parameters, and
+       A is more specific than B if all implicit parameters in either alternative are
        replaced by regular parameters.
 
 [//]: # todo: expand with precise rules

tests/run/implicit-specifity.scala

@@ -35,8 +35,4 @@ object Test extends App {
   assert(Show[String] == 1)
   assert(Show[Generic] == 1)   // showGen loses against fallback due to longer argument list
   assert(Show[Generic2] == 2)  // ... but the opaque type intersection trick works.
-
-  { import implied Contextual._
-    assert(Show[Generic] == 4) // shorter, more specific implicit parameter list wins
-  }
 }

tests/run/overloading-specifity.scala

@@ -12,16 +12,11 @@ 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 == 1)
   assert(b.foo[Int].i == 2)
 
   def f: Int = 1