Don't flip contravariant type arguments for overloading resolution

Flipping contravariant type arguments was needed for implicit search
where it will be replaced by a more general scheme. But it makes no
sense for overloading resolution. For overloading resolution, we want
to pick the most specific alternative, analogous to us picking the
most specific instantiation when we force a fully defined type.

Author: odersky

compiler/src/dotty/tools/dotc/core/Mode.scala

@@ -41,6 +41,8 @@ object Mode {
   val Pattern: Mode = newMode(0, "Pattern")
   val Type: Mode = newMode(1, "Type")
 
+  val PatternOrTypeBits: Mode = Pattern | Type
+
   val ImplicitsEnabled: Mode = newMode(2, "ImplicitsEnabled")
   val InferringReturnType: Mode = newMode(3, "InferringReturnType")
 
@@ -120,8 +122,6 @@ object Mode {
   /** Read original positions when unpickling from TASTY */
   val ReadPositions: Mode = newMode(17, "ReadPositions")
 
-  val PatternOrTypeBits: Mode = Pattern | Type
-
   /** We are elaborating the fully qualified name of a package clause.
    *  In this case, identifiers should never be imported.
    */

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

@@ -1637,7 +1637,7 @@ trait Applications extends Compatibility {
    *  an alternative that takes more implicit parameters wins over one
    *  that takes fewer.
    */
-  def compare(alt1: TermRef, alt2: TermRef)(using Context): Int = trace(i"compare($alt1, $alt2)", overload) {
+  def compare(alt1: TermRef, alt2: TermRef, preferGeneral: Boolean = false)(using Context): Int = trace(i"compare($alt1, $alt2)", overload) {
     record("resolveOverloaded.compare")
 
     /** Is alternative `alt1` with type `tp1` as specific as alternative
@@ -1722,7 +1722,9 @@ trait Applications extends Compatibility {
      *  the intersection of its parent classes instead.
      */
     def isAsSpecificValueType(tp1: Type, tp2: Type)(using Context) =
-      if (ctx.mode.is(Mode.OldOverloadingResolution))
+      if !preferGeneral || ctx.mode.is(Mode.OldOverloadingResolution) then
+        // Normal specificity test for overloading resultion (where `preferGeneral` is false)
+        // and in mode Scala3-migration when we compare with the old Scala 2 rules.
         isCompatible(tp1, tp2)
       else {
         val flip = new TypeMap {

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

@@ -1291,7 +1291,7 @@ trait Implicits:
       def compareAlternatives(alt1: RefAndLevel, alt2: RefAndLevel): Int =
         if alt1.ref eq alt2.ref then 0
         else if alt1.level != alt2.level then alt1.level - alt2.level
-        else explore(compare(alt1.ref, alt2.ref))(using searchContext())
+        else explore(compare(alt1.ref, alt2.ref, preferGeneral = true))(using searchContext())
 
       /** If `alt1` is also a search success, try to disambiguate as follows:
        *    - If alt2 is preferred over alt1, pick alt2, otherwise return an
@@ -1327,7 +1327,7 @@ trait Implicits:
                     ctx.typerState
 
                 diff = inContext(searchContext().withTyperState(comparisonState)) {
-                  compare(ref1, ref2)
+                  compare(ref1, ref2, preferGeneral = true)
                 }
               case _ =>
           if diff < 0 then alt2

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

@@ -296,7 +296,7 @@ trait ImportSuggestions:
       var i = 0
       var diff = 0
       while i < filled && diff == 0 do
-        diff = compare(ref, top(i))(using noImplicitsCtx)
+        diff = compare(ref, top(i), preferGeneral = true)(using noImplicitsCtx)
         if diff > 0 then
           rest += top(i)
           top(i) = ref

tests/pos/overload-disambiguation.scala

@@ -0,0 +1,13 @@
+class A
+class B
+class C[-T]
+
+def foo(using A): C[Any] = ???
+def foo(using B): C[Int] = ???
+
+
+@main def Test =
+  given A = A()
+  given B = B()
+  val x = foo
+  val _: C[Any] = x