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 are not allowed in Scala. " +
+              i"The following conversions are in scope:${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 can 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 */

tests/neg/i16453.check

@@ -0,0 +1,18 @@
+-- [E172] Type Error: tests/neg/i16453.scala:14:21 ---------------------------------------------------------------------
+14 |  summon[Option[Int]] // error
+   |                     ^
+   |No given instance of type Option[Int] was found for parameter x of method summon in object Predef
+   |
+   |Note: Chaining implicit conversions are not allowed in Scala. The following conversions are in scope:
+   |  - final given def given_Conversion_T_Option[T]: Conversion[T, Option[T]]
+   |  - implicit def toOption[T](t: T): Option[T]
+   |If there is an implicit `Conversion[A, Option[Int]]` and an implicit `A` in scope, you can explicitly pass the argument, e.g. `(using summon[A])`
+-- [E172] Type Error: tests/neg/i16453.scala:15:25 ---------------------------------------------------------------------
+15 |  implicitly[Option[Int]] // error
+   |                         ^
+   |No given instance of type Option[Int] was found for parameter e of method implicitly in object Predef
+   |
+   |Note: Chaining implicit conversions are not allowed in Scala. The following conversions are in scope:
+   |  - final given def given_Conversion_T_Option[T]: Conversion[T, Option[T]]
+   |  - implicit def toOption[T](t: T): Option[T]
+   |If there is an implicit `Conversion[A, Option[Int]]` and an implicit `A` in scope, you can explicitly pass the argument, e.g. `(using summon[A])`

tests/neg/i16453.scala

@@ -0,0 +1,16 @@
+import scala.language.implicitConversions
+
+// Scala 3 style conversion
+given [T]: Conversion[T, Option[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
+
+  summon[Option[Int]] // error
+  implicitly[Option[Int]] // error
+}