Special case in TestApplication

Author: tanishiking

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

@@ -883,7 +883,27 @@ trait Applications extends Compatibility {
             case SAMType(samMeth, samParent) => argtpe <:< samMeth.toFunctionType(isJava = samParent.classSymbol.is(JavaDefined))
             case _ => false
 
-        isCompatible(argtpe, formal)
+        // For overload resolution, allow wildcard upper bounds to match their bound type.
+        // For example, given:
+        //   def blub[T](a: Class[? <: T]): String = "a"
+        //   def blub[T](a: Class[T], ints: Int*): String = "b"
+        //   blub(classOf[Object])
+        //
+        // The non-varargs overload should be preferred. While Class[? <: T] is not a
+        // subtype of Class[T] (Class is invariant), for overload resolution we consider
+        // Class[? <: T] "applicable" where Class[T] is expected by checking if the
+        // wildcard's upper bound is a subtype of the formal type parameter.
+        def wildcardArgOK =
+          (argtpe, formal) match
+            case (AppliedType(tycon1, args1), AppliedType(tycon2, args2))
+            if tycon1 =:= tycon2 && args1.length == args2.length =>
+              args1.lazyZip(args2).forall {
+                case (TypeBounds(_, hi), formal) => hi relaxed_<:< formal
+                case (arg, formal) => arg =:= formal
+              }
+            case _ => false
+
+        isCompatible(argtpe, formal) || wildcardArgOK
         // Only allow SAM-conversion to PartialFunction if implicit conversions
         // are enabled. This is necessary to avoid ambiguity between an overload
         // taking a PartialFunction and one taking a Function1 because
@@ -2176,20 +2196,7 @@ trait Applications extends Compatibility {
           case  0 =>
             if winsType1 != winsType2 then if winsType1 then 1 else -1
             else if alt1.symbol == alt2.symbol then comparePrefixes
-            else
-              // Prefer non-varargs methods over varargs methods as a final tiebreaker.
-              // While `isAsGood` normally handles this, it can fail when wildcard types are involved.
-              // For example, when comparing:
-              //   def m[T](a: Class[? <: T]): Unit
-              //   def m[T](a: Class[T], ints: Int*): Unit
-              // Both winsType1 and winsType2 are false because Class[? <: T] is not
-              // a subtype of Class[T] (Class is invariant). This tiebreaker ensures the
-              // non-varargs method is preferred in such cases.
-              val tp1IsVarArgs = tp1.isVarArgsMethod
-              val tp2IsVarArgs = tp2.isVarArgsMethod
-              if tp1IsVarArgs == tp2IsVarArgs then 0
-              else if tp1IsVarArgs then -1  // alt2 (non-varargs) wins
-              else 1  // alt1 (non-varargs) wins
+            else 0
     end compareWithTypes
 
     if alt1.symbol.is(PhantomSymbol) && !alt2.symbol.is(PhantomSymbol) then -1

tests/run/overload_repeated/B_2.scala

@@ -17,6 +17,9 @@ object Test {
   def bar5[T](a: Class[? <: T]): Int = 1
   def bar5[T](a: Class[T], ints: Int*): Int = 2
 
+  def bar6[T](a: Int): Int = 1
+  def bar6[T](a: Class[T], ints: Int*): Int = 2
+
   def main(args: Array[String]): Unit = {
     // In Java, varargs are always less specific than non-varargs (see
     // https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.12.2),
@@ -33,5 +36,6 @@ object Test {
     assert(bar3("") == 1) // same in Scala 2
     assert(bar4("") == 1) // same in Scala 2
     assert(bar5(classOf[Object]) == 1) // same in Scala2
+    assert(bar6(classOf[Object]) == 2) // same in Scala2
   }
 }