WIP fix for overloading resolution

Author: abgruszecki

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

@@ -1293,7 +1293,15 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
         val formals1 =
           if (tp1.isVarArgsMethod && tp2.isVarArgsMethod) tp1.paramInfos.map(_.repeatedToSingle)
           else tp1.paramInfos
-        isApplicable(alt2, formals1, WildcardType) ||
+
+        class IsAsSpecific(methRef: TermRef, args: List[Type], resultType: Type)(implicit ctx: Context)
+          extends ApplicableToTypes(methRef, args, resultType) {
+          override def argOK(arg: TypedArg, formal: Type): Boolean =
+            // simulate X* not being in subtyping relationship with any other type
+            !(arg.isRepeatedParam || formal.isRepeatedParam) && super.argOK(arg, formal)
+        }
+
+        ctx.test(ctx => new IsAsSpecific(alt2, formals1, WildcardType)(ctx).success) ||
         tp1.paramInfos.isEmpty && tp2.isInstanceOf[LambdaType]
       case tp1: PolyType => // (2)
         val nestedCtx = ctx.fresh.setExploreTyperState()
@@ -1420,24 +1428,45 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
 	      if (winsType1 || !winsType2) 1 else 0
 	    else if (ownerScore == -1)
 	      if (winsType2 || !winsType1) -1 else 0
-	    else if (winsType1)
+      else if (winsType1)
 	      if (winsType2) 0 else 1
 	    else
         if (winsType2) -1 else 0
     }
 
-    val fullType1 = widenImplied(alt1.widen, alt1)
-    val fullType2 = widenImplied(alt2.widen, alt2)
+    def paramInfos(tp: Type): List[Type] = tp.stripPoly match {
+      case mt: MethodType => mt.paramInfos
+      case _ => Nil
+    }
+
+    @annotation.tailrec def lengthCompare(xs: List[_], ys: List[_]): Int = (xs, ys) match {
+      case (_ :: xs, _ :: ys) => lengthCompare(xs, ys)
+      case (Nil, Nil) => 0
+      case (_, Nil) => 1
+      case (Nil, _) => -1
+    }
+
+    val wideAlt1 = alt1.widen
+    val wideAlt2 = alt2.widen
+    val fullType1 = widenImplied(wideAlt1, alt1)
+    val fullType2 = widenImplied(wideAlt2, alt2)
     val strippedType1 = stripImplicit(fullType1)
     val strippedType2 = stripImplicit(fullType2)
 
     val result = compareWithTypes(strippedType1, strippedType2)
-    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
+    if (result != 0) result else {
+      val varArgLengthTiebreaker =
+        if (wideAlt1.isVarArgsMethod || wideAlt2.isVarArgsMethod)
+          lengthCompare(paramInfos(wideAlt1), paramInfos(wideAlt2))
+        else 0
+
+      if (varArgLengthTiebreaker != 0) varArgLengthTiebreaker
+      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") {
@@ -1674,6 +1703,8 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
       candidates.flatMap(cloneCandidate)
     }
 
+    import config.Printers.debug
+    debug.println(i"candidates=\n\t$candidates%\n\t%")
     val found = narrowMostSpecific(candidates)
     if (found.length <= 1) found
     else pt match {

tests/neg/overload_repeated.scala

@@ -0,0 +1,5 @@
+object Test {
+  def foo(a: Any) = a
+  def foo(s: String*) = s
+  foo("") // error
+}

tests/pos/overload_poly_repeated.scala

@@ -0,0 +1,14 @@
+class C {
+  def foo(xs: Int*): Int = xs.toSeq.head
+  def foo(x: Int): Int = x
+  foo(2)
+
+  def fooT[T](xs: T*): T = xs.toSeq.head
+  def fooT[T](x: T): T = x
+  fooT(2)
+
+  def f[T](x: T): T = x
+  def f[T](x: T, xs: T*): T = x
+
+  f(5)
+}

tests/pos/t4775/JavaClass.java

@@ -0,0 +1,25 @@
+public class JavaClass {
+    public static class Element {
+
+    }
+
+    public static <T extends Element> int foo(Element a, Class<T> b, boolean c, Class<? extends T>... d) {
+        return 1;
+    }
+
+    public static <T extends Element> int foo(Element a, Class<? extends T> b, boolean c) {
+        return 2;
+    }
+
+    public static <T extends Element> int foo(Element a, Class<? extends T>... b) {
+        return 3;
+    }
+
+    public static <T extends Element> int foo(Element a, boolean b, Class<? extends T>... c) {
+        return 4;
+    }
+
+    static {
+        foo(new Element(), Element.class, false);
+    }
+}

tests/pos/t4775/Test.scala

@@ -0,0 +1,4 @@
+class Test {
+  import JavaClass._
+  foo(new Element, classOf[Element], false)
+}