Fix healAmbiguous to compareAlternatives with disambiguate = true

On the final result, compared with all the ambiguous candidates we are trying
to recover from. We should still use `disambiguate = false` when filtering the
`pending` candidates for the purpose of warnings, as in the other cases.

Before, we could heal an ambiguous SearchFailure with a candidate which was
considered better only under the alternative given prioritization scheme,
see #21045 for details.

Author: EugeneFlesselle

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

@@ -1419,15 +1419,7 @@ trait Implicits:
           if diff < 0 then alt2
           else if diff > 0 then alt1
           else SearchFailure(new AmbiguousImplicits(alt1, alt2, pt, argument), span)
-        case fail: SearchFailure =>
-          fail.reason match
-            case ambi: AmbiguousImplicits =>
-              if compareAlternatives(ambi.alt1, alt2, disambiguate = true) < 0
-                && compareAlternatives(ambi.alt2, alt2, disambiguate = true) < 0
-              then alt2
-              else alt1
-            case _ =>
-              alt2
+        case _: SearchFailure => alt2
 
       /** Try to find a best matching implicit term among all the candidates in `pending`.
        *  @param pending   The list of candidates that remain to be tested
@@ -1454,9 +1446,14 @@ trait Implicits:
              *  candidate that is strictly better than the failed candidate(s).
              *  If no such candidate is found, we propagate the ambiguity.
              */
-            def healAmbiguous(fail: SearchFailure, betterThanFailed: Candidate => Boolean) =
-              val newPending = remaining.filter(betterThanFailed)
-              rank(newPending, fail, Nil).recoverWith(_ => fail)
+            def healAmbiguous(fail: SearchFailure, ambiguousCands: List[RefAndLevel]) =
+              def betterThanAll(newCand: RefAndLevel, disambiguate: Boolean): Boolean =
+                ambiguousCands.forall(compareAlternatives(newCand, _, disambiguate) > 0)
+
+              val newPending = remaining.filter(betterThanAll(_, disambiguate = false))
+              rank(newPending, fail, Nil) match
+                case found: SearchSuccess if betterThanAll(found, disambiguate = true) => found
+                case _ => fail
 
             negateIfNot(tryImplicit(cand, contextual)) match {
               case fail: SearchFailure =>
@@ -1471,8 +1468,7 @@ trait Implicits:
                   else
                     // The ambiguity happened in a nested search: to recover we
                     // need a candidate better than `cand`
-                    healAmbiguous(fail, newCand =>
-                      compareAlternatives(newCand, cand) > 0)
+                    healAmbiguous(fail, cand :: Nil)
                 else
                   // keep only warnings that don't involve the failed candidate reference
                   priorityChangeWarnings.filterInPlace: (critical, _) =>
@@ -1491,9 +1487,7 @@ trait Implicits:
                     // The ambiguity happened in the current search: to recover we
                     // need a candidate better than the two ambiguous alternatives.
                     val ambi = fail.reason.asInstanceOf[AmbiguousImplicits]
-                    healAmbiguous(fail, newCand =>
-                      compareAlternatives(newCand, ambi.alt1) > 0 &&
-                      compareAlternatives(newCand, ambi.alt2) > 0)
+                    healAmbiguous(fail, ambi.alt1 :: ambi.alt2 :: Nil)
                 }
             }
           case nil =>