Strengthen overloading resolution to deal with extension methods

If resolving with the first parameter list yields a draw, and there are
further argument lists following the first one, take these into account
as well in order to arrive at a single best alternative.

This is particularly useful for extension methods, where we might
well have several overloaded extension methods with the same first
parameter list.

Author: odersky

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

@@ -1632,16 +1632,50 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
           }
         else compat
     }
+
+    /** For each candidate `C`, a proxy termref paired with `C`.
+     *  The proxy termref has as symbol a copy of the original candidate symbol,
+     *  with an info that strips the first value parameter list away.
+     *  @param  argTypes  The types of the arguments of the FunProto `pt`.
+     */
+    def advanceCandidates(argTypes: List[Type]): List[(TermRef, TermRef)] = {
+      def strippedType(tp: Type): Type = tp match {
+        case tp: PolyType =>
+          val rt = strippedType(tp.resultType)
+          if (rt.exists) tp.derivedLambdaType(resType = rt) else rt
+        case tp: MethodType =>
+          tp.instantiate(argTypes)
+        case _ =>
+          NoType
+      }
+      def cloneCandidate(cand: TermRef): List[(TermRef, TermRef)] = {
+        val strippedInfo = strippedType(cand.widen)
+        if (strippedInfo.exists) {
+          val sym = cand.symbol.asTerm.copy(info = strippedInfo)
+          (TermRef(cand.prefix, sym), cand) :: Nil
+        }
+        else Nil
+      }
+      overload.println(i"look at more params: ${candidates.head.symbol}: ${candidates.map(_.widen)}%, % with $pt, [$targs%, %]")
+      candidates.flatMap(cloneCandidate)
+    }
+
     val found = narrowMostSpecific(candidates)
     if (found.length <= 1) found
-    else {
-      val noDefaults = alts.filter(!_.symbol.hasDefaultParams)
-      if (noDefaults.length == 1) noDefaults // return unique alternative without default parameters if it exists
-      else {
-        val deepPt = pt.deepenProto
-        if (deepPt ne pt) resolveOverloaded(alts, deepPt, targs)
-        else alts
-      }
+    else pt match {
+      case pt @ FunProto(_, resType: FunProto) =>
+        // try to narrow further with snd argument list
+        val advanced = advanceCandidates(pt.typedArgs.tpes)
+        resolveOverloaded(advanced.map(_._1), resType, Nil) // resolve with candidates where first params are stripped
+          .map(advanced.toMap) // map surviving result(s) back to original candidates
+      case _ =>
+        val noDefaults = alts.filter(!_.symbol.hasDefaultParams)
+        if (noDefaults.length == 1) noDefaults // return unique alternative without default parameters if it exists
+        else {
+          val deepPt = pt.deepenProto
+          if (deepPt ne pt) resolveOverloaded(alts, deepPt, targs)
+          else alts
+        }
     }
   }
 

tests/run/extmethod-overload.scala

@@ -0,0 +1,36 @@
+object Test extends App {
+  // warmup
+  def f(x: Int)(y: Int) = y
+  def f(x: Int)(y: String) = y.length
+  assert(f(1)(2) == 2)
+  assert(f(1)("two") == 3)
+
+  def g[T](x: T)(y: Int) = y
+  def g[T](x: T)(y: String) = y.length
+  assert(g[Int](1)(2) == 2)
+  assert(g[Int](1)("two") == 3)
+  assert(g(1)(2) == 2)
+  assert(g(1)("two") == 3)
+
+  def h[T](x: T)(y: T)(z: Int) = z
+  def h[T](x: T)(y: T)(z: String) = z.length
+  assert(h[Int](1)(1)(2) == 2)
+  assert(h[Int](1)(1)("two") == 3)
+  assert(h(1)(1)(2) == 2)
+  assert(h(1)(1)("two") == 3)
+
+  implied Foo {
+    def (x: Int) |+| (y: Int) = x + y
+    def (x: Int) |+| (y: String) = x + y.length
+
+    def (xs: List[T]) +++ [T] (ys: List[T]): List[T] = xs ++ ys ++ ys
+    def (xs: List[T]) +++ [T] (ys: Iterator[T]): List[T] = xs ++ ys ++ ys
+  }
+
+  assert((1 |+| 2) == 3)
+  assert((1 |+| "2") == 2)
+
+  val xs = List(1, 2)
+  assert((xs +++ xs).length == 6)
+  assert((xs +++ xs.iterator).length == 4, xs +++ xs.iterator)
+}