Properly recover from nested ambiguous implicit search failures

From
http://dotty.epfl.ch/docs/reference/changed-features/implicit-resolution.html:

> The treatment of ambiguity errors has changed. If an ambiguity is
> encountered in some recursive step of an implicit search, the ambiguity
> is propagated to the caller.

This is supposed to be handled by `healAmbiguous` but the implementation
was incorrect: it compared pending candidates against the two ambiguous
results from the search, but this doesn't make sense when the failure
happened in a nested search: for example in `i9793`, the failure is:

    Applied.bazApplied[F](/* ambiguous: both value baz and value bar match type Foo[F] */summon[Foo[F])

We should be able to recover from this failure because `barApplied` is
more specific than `bazApplied`, but before this commit we ended up
comparing `barApplied` to `baz` and `bar` which isn't meaningful.

Fixes #9793.

Author: smarter

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

@@ -1169,18 +1169,6 @@ trait Implicits:
           else SearchFailure(new AmbiguousImplicits(alt1, alt2, pt, argument))
         case _: SearchFailure => alt2
 
-      /** Faced with an ambiguous implicits failure `fail`, try to find another
-       *  alternative among `pending` that is strictly better than both ambiguous
-       *  alternatives.  If that fails, return `fail`
-       */
-      def healAmbiguous(pending: List[Candidate], fail: SearchFailure) = {
-        val ambi = fail.reason.asInstanceOf[AmbiguousImplicits]
-        val newPending = pending.filter(cand =>
-          compareAlternatives(ambi.alt1, cand) < 0 &&
-          compareAlternatives(ambi.alt2, cand) < 0)
-        rank(newPending, fail, Nil).recoverWith(_ => fail)
-      }
-
       /** 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
        *  @param found     The result obtained from previously tried candidates
@@ -1194,14 +1182,22 @@ trait Implicits:
        *     worse than the successful candidate.
        *  If a trial failed:
        *    - if the query term is a `Not[T]` treat it as a success,
-       *    - otherwise, if the failure is an ambiguity, try to heal it (see @healAmbiguous)
+       *    - otherwise, if the failure is an ambiguity, try to heal it (see `healAmbiguous`)
        *      and return an ambiguous error otherwise. However, under Scala2 mode this is
        *      treated as a simple failure, with a warning that semantics will change.
        *    - otherwise add the failure to `rfailures` and continue testing the other candidates.
        */
       def rank(pending: List[Candidate], found: SearchResult, rfailures: List[SearchFailure]): SearchResult =
         pending match {
           case cand :: remaining =>
+            /** To recover from an ambiguous implicit failure, we need to find a pending
+             *  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)
+
             negateIfNot(tryImplicit(cand, contextual)) match {
               case fail: SearchFailure =>
                 if (fail.isAmbiguous)
@@ -1210,7 +1206,11 @@ trait Implicits:
                     if (result.isSuccess)
                       warnAmbiguousNegation(fail.reason.asInstanceOf[AmbiguousImplicits])
                     result
-                  else healAmbiguous(remaining, fail)
+                  else
+                    // The ambiguity happened in a nested search: to recover we
+                    // need a candidate better than `cand`
+                    healAmbiguous(fail, newCand =>
+                      compareAlternatives(newCand, cand) > 0)
                 else rank(remaining, found, fail :: rfailures)
               case best: SearchSuccess =>
                 if (ctx.mode.is(Mode.ImplicitExploration) || isCoherent)
@@ -1223,7 +1223,12 @@ trait Implicits:
                         compareAlternatives(retained, cand) <= 0)
                     rank(newPending, retained, rfailures)
                   case fail: SearchFailure =>
-                    healAmbiguous(remaining, fail)
+                    // 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)
                 }
             }
           case nil =>

tests/pos/i9793.scala

@@ -0,0 +1,20 @@
+trait Foo[F[_]]
+
+trait Bar[F[_]] extends Foo[F]
+trait Baz[F[_]] extends Foo[F]
+
+case class Applied[F[_], A](a: F[A])
+
+
+object Applied extends AppliedLowPrio {
+  implicit def barApplied[F[_]: Baz]: Baz[({ type L[X] = Applied[F, X] })#L] = ???
+}
+
+trait AppliedLowPrio {
+  implicit def bazApplied[F[_]: Foo]: Foo[({ type L[X] = Applied[F, X] })#L] = ???
+}
+
+
+object Test {
+  def test[F[_]](implicit bar: Bar[F], baz: Baz[F]) = implicitly[Foo[({ type L[X] = Applied[F, X] })#L]]
+}