Simulate Repeated having no sub/supertypes for overloads

Author: abgruszecki

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

@@ -1293,7 +1293,19 @@ 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.
+            // This is necessary in cases when the last parameter of one method is repeated,
+            // and another is, for instance, Any - see neg/overload_repeated.scala.
+            // Note that we cannot just say that X* is really not a sub- or supertype of any other type,
+            // since that would interfere with typing method bodies.
+            !(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()

tests/neg/overload_repeated.scala

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

tests/neg/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/neg/t4775/Test.scala

@@ -0,0 +1,24 @@
+class Test {
+  import JavaClass._
+  // in Scala2, this is not actually an error (see https://github.com/scala/bug/issues/4775)
+  // overloading selection needs to decide between:
+  //
+  // def foo[T <: Element](a: Element, b: Class[T], c: Boolean, d: Class[_ <: T]*)
+  // def foo[T <: Element](a: Element, b: Class[_ <: T], c: Boolean)
+  //
+  // The first is not as specific as the second, since it has more arguments.
+  // The second _should_ be as specific as the first,
+  // but the T parameter would need to capture the wildcard of b.
+  // Since we don't allow wildcard capture anymore,
+  // we cannot infer anything for T
+  // and just say the second is not as specific as the first either.
+  //
+  // As a note to whomever will be revisiting this in the future,
+  // we can select the same overload as Scala2 by selecting the one
+  // without vararg parameter when neither is more specific.
+  // The argument is that since one overload has varargs and the other doesn't,
+  // the callsite must be trying to pass no varargs,
+  // so we should select the overload that doesn't actually have any.
+  // This breaks no tests, but potentially allows too much.
+  foo(new Element, classOf[Element], false) // 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)
+}