Use ctx.implicits.eligible directly

Author: ysthakur

compiler/src/dotty/tools/dotc/reporting/messages.scala

@@ -2555,7 +2555,7 @@ class MissingImplicitArgument(
     where: String,
     paramSymWithMethodCallTree: Option[(Symbol, tpd.Tree)] = None,
     ignoredInstanceNormalImport: => Option[SearchSuccess],
-    ignoredConversions: => Set[SearchSuccess]
+    ignoredConversions: => Iterable[TermRef]
   )(using Context) extends TypeMsg(MissingImplicitArgumentID), ShowMatchTrace(pt):
 
   arg.tpe match
@@ -2744,9 +2744,9 @@ class MissingImplicitArgument(
         // show all available additional info
         def hiddenImplicitNote(s: SearchSuccess) =
           i"\n\nNote: ${s.ref.symbol.showLocated} was not considered because it was not imported with `import given`."
-        def noChainConversionsNote(s: Set[SearchSuccess]): Option[String] =
-          Option.when(s.isEmpty)(
-              i"\n\nNote: Chaining implicit conversions is no longer allowed in Scala. The following conversions were ignored: ${s.map(_.ref.symbol.showLocated).mkString("\n")}"
+        def noChainConversionsNote(s: Iterable[TermRef]): Option[String] =
+          Option.when(s.nonEmpty)(
+              i"\n\nNote: Chaining implicit conversions is no longer allowed in Scala. The following conversions were ignored:${s.map(g => "\n  - " + g.symbol.showLocated).mkString}"
           )
         super.msgPostscript
         ++ ignoredInstanceNormalImport.map(hiddenImplicitNote)

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

@@ -926,9 +926,10 @@ trait Implicits:
     def ignoredConversions = arg.tpe match
       case fail: SearchFailureType =>
         if (fail.expectedType eq pt) || isFullyDefined(fail.expectedType, ForceDegree.none) then
-          ImplicitSearch(fail.expectedType, dummyTreeOfType(WildcardType), arg.span).allImplicits
+          ctx.implicits.eligible(ViewProto(WildcardType, wildApprox(fail.expectedType)))
+            .collect { case c if c.isConversion => c.ref }
         else
-          Set.empty
+          Nil
 
     MissingImplicitArgument(arg, pt, where, paramSymWithMethodCallTree, ignoredInstanceNormalImport, ignoredConversions)
   }

compiler/test/dotty/tools/dotc/CompilationTests.scala

@@ -188,6 +188,7 @@ class CompilationTests {
       compileFile("tests/neg-custom-args/i13026.scala", defaultOptions.and("-print-lines")),
       compileFile("tests/neg-custom-args/i13838.scala", defaultOptions.and("-Ximplicit-search-limit", "1000")),
       compileFile("tests/neg-custom-args/jdk-9-app.scala", defaultOptions.and("-release:8")),
+      compileFile("tests/neg/i16453.scala", defaultOptions),
     ).checkExpectedErrors()
   }
 

tests/neg/i16453.check

@@ -0,0 +1,7 @@
+-- [E172] Type Error: tests/neg/i16453.scala:10:43 ---------------------------------------------------------------------
+10 |  val fails = summon[String => Option[Int]] // error
+   |                                           ^
+   |     No given instance of type String => Option[Int] was found for parameter x of method summon in object Predef
+   |
+   |     Note: Chaining implicit conversions is no longer allowed in Scala. The following conversions were ignored:
+   |       - given instance given_Conversion_Function_Function

tests/neg/i16453.scala

@@ -0,0 +1,11 @@
+import scala.language.implicitConversions
+
+given [T]: Conversion[String => T, String => Option[T]] = ???
+// This one is irrelevant, shouldn't be included in error message
+given irrelevant[T]: Conversion[String => T, String => Byte] = ???
+
+def test() = {
+  given foo: (String => Int) = _ => 42
+
+  val fails = summon[String => Option[Int]] // error
+}