Turn mismatch given errors into given not found errors for $conforms[Nothing] and <:<.refl[Nothing]

Fixes #8053

When a given candidate turns out to not be applicable we used to report that
there is a mismatch between the candidate type and the expected type.

The goal is to report an error as precise as possible to the user. However, in some cases
showing the inferred candidate brings no value to the user, especially when the candidate
is uninhabited.

I’ve changed the failure to be a `NoMatchingImplicitsFailure` instead of a mismatch when
`$conforms[Nothing]` or `<:<.refl` are inferred because these values are uninhabited and
might be confusing for end users.

Author: julienrf

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

@@ -1407,11 +1407,15 @@ trait Implicits { self: Typer =>
         }
       if (ctx.reporter.hasErrors) {
         ctx.reporter.removeBufferedMessages
-        SearchFailure {
-          adapted.tpe match {
-            case _: SearchFailureType => adapted
-            case _ => adapted.withType(new MismatchedImplicit(ref, pt, argument))
-          }
+        adapted.tpe match {
+          case _: SearchFailureType => SearchFailure(adapted)
+          case _ =>
+            // Special case for `$conforms[Nothing]` and `<:<.refl[Nothing]`. Showing them
+            // up to the users brings no value, so we instead report a `NoMatchingImplicitsFailure`
+            if (adapted.show == "$conforms[Nothing]" || adapted.show == "<:<.refl[Nothing]")
+              NoMatchingImplicitsFailure
+            else
+              SearchFailure(adapted.withType(new MismatchedImplicit(ref, pt, argument)))
         }
       }
       else {

tests/neg/implicitSearch.check

@@ -0,0 +1,13 @@
+-- Error: tests/neg/implicitSearch.scala:13:12 -------------------------------------------------------------------------
+13 |    sort(xs)  // error (with a partially constructed implicit argument shown)
+   |            ^
+   |   no implicit argument of type Test.Ord[List[List[T]]] was found for parameter o of method sort in object Test.
+   |   I found:
+   |
+   |       Test.listOrd[T](Test.listOrd[T](/* missing */implicitly[Test.Ord[T]]))
+   |
+   |   But no implicit values were found that match type Test.Ord[T].
+-- Error: tests/neg/implicitSearch.scala:15:38 -------------------------------------------------------------------------
+15 |    listOrd(listOrd(implicitly[Ord[T]] /*not found*/)) // error
+   |                                      ^
+   |  no implicit argument of type Test.Ord[T] was found for parameter ev of method implicitly in object DottyPredef

tests/neg/implicitSearch.scala

@@ -1,7 +1,5 @@
 object Test {
 
-  type T = String
-
   class Ord[T]
   implicit def listOrd[T](implicit o: Ord[T]): Ord[List[T]] = ???
   implicit def intOrd: Ord[Int] = ???

tests/neg/missing-implicit3.check

@@ -0,0 +1,18 @@
+-- Error: tests/neg/missing-implicit3.scala:3:37 -----------------------------------------------------------------------
+3 |val sortedFoos = List(new Foo).sorted // error
+  |                                     ^
+  |                  No implicit Ordering defined for B
+  |
+  |                  where:    B is a type variable with constraint >: Foo
+  |                  ..
+  |                  I found:
+  |
+  |                      scala.math.Ordering.ordered[A](/* missing */implicitly[scala.math.Ordering.AsComparable[B]])
+  |
+  |                  But no implicit values were found that match type scala.math.Ordering.AsComparable[B].
+  |
+  |                  One of the following imports might make progress towards fixing the problem:
+  |
+  |                    import math.Ordering.comparatorToOrdering
+  |                    import math.Ordering.ordered
+  |                           

tests/neg/missing-implicit3.scala

@@ -0,0 +1,3 @@
+class Foo
+
+val sortedFoos = List(new Foo).sorted // error

tests/neg/subtyping.check

@@ -1,18 +1,8 @@
 -- Error: tests/neg/subtyping.scala:8:27 -------------------------------------------------------------------------------
 8 |    implicitly[B#X <:< A#X] // error: no implicit argument
   |                           ^
-  |                           Cannot prove that B#X <:< A#X..
-  |                           I found:
-  |
-  |                               <:<.refl[Nothing]
-  |
-  |                           But method refl in object <:< does not match type B#X <:< A#X.
+  |                           Cannot prove that B#X <:< A#X.
 -- Error: tests/neg/subtyping.scala:12:27 ------------------------------------------------------------------------------
 12 |    implicitly[a.T <:< a.U] // error: no implicit argument
    |                           ^
-   |                           Cannot prove that a.T <:< a.U..
-   |                           I found:
-   |
-   |                               <:<.refl[Nothing]
-   |
-   |                           But method refl in object <:< does not match type a.T <:< a.U.
+   |                           Cannot prove that a.T <:< a.U.

tests/neg/summon-function.check

@@ -0,0 +1,4 @@
+-- Error: tests/neg/summon-function.scala:2:23 -------------------------------------------------------------------------
+2 |  summon[Int => String] // error
+  |                       ^
+  |                       No implicit view available from Int => String.

tests/neg/summon-function.scala

@@ -0,0 +1,3 @@
+object Test {
+  summon[Int => String] // error
+}