Find all implicits first

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: => Iterable[TermRef]
+    ignoredConversions: => Iterable[(TermRef, Iterable[TermRef])]
   )(using Context) extends TypeMsg(MissingImplicitArgumentID), ShowMatchTrace(pt):
 
   arg.tpe match
@@ -2744,12 +2744,18 @@ 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(ignoredConversions: Iterable[TermRef]): Option[String] =
+        def showImplicitAndConversions(imp: TermRef, convs: Iterable[TermRef]) =
+          i"\n- ${imp.symbol.showDcl}${convs.map(c => "\n    - " + c.symbol.showDcl).mkString}"
+        def noChainConversionsNote(ignoredConversions: Iterable[(TermRef, Iterable[TermRef])]): Option[String] = {
+          val convsFormatted = ignoredConversions.map{ (imp, convs) =>
+            i"\n- ${imp.symbol.showDcl}${convs.map(c => "\n    - " + c.symbol.showDcl).mkString}"
+          }.mkString
           Option.when(ignoredConversions.nonEmpty)(
               i"\n\nNote: implicit conversions are not automatically applied to arguments of using clauses. " +
               i"You will have to pass the argument explicitly.\n" +
-              i"The following conversions in scope result in ${pt.show}: ${ignoredConversions.map(g => s"\n  - ${g.symbol.showDcl}").mkString}"
+              i"The following conversions in scope result in ${pt.show}: $convsFormatted"
           )
+        }
         super.msgPostscript
         ++ ignoredInstanceNormalImport.map(hiddenImplicitNote)
             .orElse(noChainConversionsNote(ignoredConversions))

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

@@ -923,11 +923,21 @@ trait Implicits:
           // example where searching for a nested type causes an infinite loop.
           None
 
+    def allImplicits(currImplicits: ContextualImplicits): List[ImplicitRef] =
+      if currImplicits.outerImplicits == null then currImplicits.refs
+      else currImplicits.refs ::: allImplicits(currImplicits.outerImplicits)
+
     def ignoredConversions = arg.tpe match
       case fail: SearchFailureType =>
+        // Get every implicit in scope and find Conversions for each
         if (fail.expectedType eq pt) || isFullyDefined(fail.expectedType, ForceDegree.none) then
-          ctx.implicits.eligible(ViewProto(WildcardType, wildApprox(fail.expectedType)))
-            .collect { case c if c.isConversion => c.ref }
+          // todo filter out implicit conversions
+          allImplicits(ctx.implicits).map { imp =>
+            // todo imp.underlyingRef.underlying does not work for implicit functions or givens
+            // with type or implicit parameters
+            val convs = ctx.implicits.eligible(ViewProto(imp.underlyingRef.underlying, wildApprox(fail.expectedType)))
+            (imp.underlyingRef, convs.map(_.ref))
+          }.filter(_._2.nonEmpty)
         else
           Nil
 

tests/neg/i16453.scala

@@ -1,15 +1,20 @@
 import scala.language.implicitConversions
 
+trait Foo { type T }
+
 // Scala 3 style conversion
-given [T]: Conversion[T, Option[T]] = ???
+// given [T]: Conversion[T, Option[T]] = ???
+given [F <: Foo](using f: F): Conversion[f.T, Option[f.T]] = ???
 // Scala 2 style conversion
 implicit def toOption[T](t: T): Option[T] = Option(t)
 
 // This one is irrelevant, shouldn't be included in error message
 given irrelevant: Conversion[Int, Option[Long]] = ???
 
 def test() = {
-  given foo: Int = 0
+  given foo: Foo with
+    type T = Int
+  given bar: Int = 0
 
   summon[Option[Int]] // error
   implicitly[Option[Int]] // error