Use old prioritization for old-style implicits if new is ambiguous

Author: odersky

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

@@ -1331,6 +1331,9 @@ trait Implicits:
         else if alt1.level != alt2.level then alt1.level - alt2.level
         else
           var cmp = comp(using searchContext())
+          if cmp == 0 && alt1.ref.symbol.is(Implicit) && alt2.ref.symbol.is(Implicit) then
+            // if we get an ambiguity with new rules for a pair of old-style implicits, fall back to old rules
+            cmp = comp(using searchContext().addMode(Mode.OldImplicitResolution))
           val sv = Feature.sourceVersion
           if isWarnPriorityChangeVersion(sv) then
             val prev = comp(using searchContext().addMode(Mode.OldImplicitResolution))

tests/neg/i2974.scala

@@ -15,10 +15,14 @@ object Test {
     summon[Foo[Int]] // ok
 
   locally:
-    implicit val fa: Foo[Any] = ???
-    implicit val ba: Bar[Int] = ???
+    given fa: Foo[Any] = ???
+    given ba: Bar[Int] = ???
     summon[Foo[Int]] // error: now ambiguous,
     // was resolving to `ba` when using intermediate rules:
     // better means specialize, but map all type arguments downwards
 
+  locally:
+    implicit val fa: Foo[Any] = ???
+    implicit val ba: Bar[Int] = ???
+    summon[Foo[Int]] // is OK since we fall back to old rules for old-style implicits as a tie breaker
 }