Hint about forbidden combination of implicit values and conversions

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

@@ -2554,7 +2554,8 @@ class MissingImplicitArgument(
     pt: Type,
     where: String,
     paramSymWithMethodCallTree: Option[(Symbol, tpd.Tree)] = None,
-    ignoredInstanceNormalImport: => Option[SearchSuccess]
+    ignoredInstanceNormalImport: => Option[SearchSuccess],
+    ignoredConversions: => Iterable[TermRef]
   )(using Context) extends TypeMsg(MissingImplicitArgumentID), ShowMatchTrace(pt):
 
   arg.tpe match
@@ -2743,8 +2744,15 @@ 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: Iterable[TermRef]): Option[String] =
+          Option.when(s.nonEmpty)(
+              i"\n\nNote: Chaining implicit conversions is no longer allowed in Scala. " +
+              i"The following conversions were ignored:${s.map(g => s"\n  - ${g.symbol.showDcl}").mkString}" +
+              i"\nIf there is an implicit `Conversion[A, ${pt.show}]` and an implicit `A` in scope, you need to explicitly pass the argument, e.g. `(using summon[A])`"
+          )
         super.msgPostscript
         ++ ignoredInstanceNormalImport.map(hiddenImplicitNote)
+            .orElse(noChainConversionsNote(ignoredConversions))
             .getOrElse(ctx.typer.importSuggestionAddendum(pt))
 
   def explain(using Context) = ""

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

@@ -923,7 +923,15 @@ trait Implicits:
           // example where searching for a nested type causes an infinite loop.
           None
 
-    MissingImplicitArgument(arg, pt, where, paramSymWithMethodCallTree, ignoredInstanceNormalImport)
+    def ignoredConversions = arg.tpe match
+      case fail: SearchFailureType =>
+        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 }
+        else
+          Nil
+
+    MissingImplicitArgument(arg, pt, where, paramSymWithMethodCallTree, ignoredInstanceNormalImport, ignoredConversions)
   }
 
   /** A string indicating the formal parameter corresponding to a  missing argument */

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,8 @@
+-- [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:
+   |  - final given def given_Conversion_Function_Function[T]: Conversion[String => T, String => Option[T]]
+   |If there is an implicit `Conversion[A, String => Option[Int]]` and an implicit `A` in scope, you need to explicitly pass the argument, e.g. `(using summon[A])`

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
+}