Use typed directly instead of finding conversions

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, Iterable[TermRef])]
+    ignoredConvertibleImplicits: => Iterable[TermRef]
   )(using Context) extends TypeMsg(MissingImplicitArgumentID), ShowMatchTrace(pt):
 
   arg.tpe match
@@ -2746,19 +2746,16 @@ class MissingImplicitArgument(
           i"\n\nNote: ${s.ref.symbol.showLocated} was not considered because it was not imported with `import given`."
         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) =>
-            s"\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}: $convsFormatted"
+        def noChainConversionsNote(ignoredConvertibleImplicits: Iterable[TermRef]): Option[String] =
+          Option.when(ignoredConvertibleImplicits.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 implicits in scope can be converted to ${pt.show}:" +
+            ignoredConvertibleImplicits.map { imp => s"\n- ${imp.symbol.showDcl}"}.mkString
           )
-        }
         super.msgPostscript
         ++ ignoredInstanceNormalImport.map(hiddenImplicitNote)
-            .orElse(noChainConversionsNote(ignoredConversions))
+            .orElse(noChainConversionsNote(ignoredConvertibleImplicits))
             .getOrElse(ctx.typer.importSuggestionAddendum(pt))
 
   def explain(using Context) = ""

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

@@ -934,26 +934,34 @@ trait Implicits:
       case _ => true
     }
 
+    def isScala2Conv(typ: Type): Boolean = typ match {
+      case PolyType(_, resType) => isScala2Conv(resType)
+      case mt: MethodType =>
+        (!mt.resultType.isImplicitMethod && !mt.resultType.isContextualMethod)
+          || isScala2Conv(mt.resultType)
+      case _ => false
+    }
+
     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
-          // todo filter out implicit conversions
           allImplicits(ctx.implicits)
-            .filter(imp => notImplicitConv(imp.underlyingRef.underlying))
-            .map { imp =>
-              val impRef = imp.underlyingRef
-              val impResultType = wildApprox(impRef.underlying.finalResultType)
-              val convs = ctx.implicits.eligible(ViewProto(impResultType, fail.expectedType))
-                .filter { conv =>
-                  if !conv.isConversion then false
-                  else
-                    // TODO Actually feed the summoned implicit into the Conversion to
-                    // check if it works
-                    true
-                }
-              (impRef, convs.map(_.ref))
-            }.filter(_._2.nonEmpty)
+            .map(_.underlyingRef)
+            .filter { imp =>
+              if notImplicitConv(imp.underlying) then false
+              else
+                val locked = ctx.typerState.ownedVars
+                val tryCtx = ctx.fresh
+                val tried = Contexts.withMode(Mode.Printing) {
+                    typed(
+                      tpd.ref(imp).withSpan(arg.span),
+                      fail.expectedType,
+                      locked
+                    )
+                  }(using tryCtx)
+                !tryCtx.reporter.hasErrors && fail.expectedType =:= tried.tpe
+            }
         else
           Nil
 

tests/neg/i16453.check

@@ -1,18 +1,12 @@
--- [E172] Type Error: tests/neg/i16453.scala:14:21 ---------------------------------------------------------------------
-14 |  summon[Option[Int]] // error
+-- [E172] Type Error: tests/neg/i16453.scala:19:21 ---------------------------------------------------------------------
+19 |  summon[Option[Int]] // error
    |                     ^
    |No given instance of type Option[Int] was found for parameter x of method summon in object Predef
    |
    |Note: implicit conversions are not automatically applied to arguments of using clauses. You will have to pass the argument explicitly.
-   |The following conversions in scope result in Option[Int]: 
-   |  - final given def given_Conversion_T_Option[T]: Conversion[T, Option[T]]
-   |  - implicit def toOption[T](t: T): Option[T]
--- [E172] Type Error: tests/neg/i16453.scala:15:25 ---------------------------------------------------------------------
-15 |  implicitly[Option[Int]] // error
+   |The following conversions in scope can be converted to Option[Int]:
+   |- given bar: Int
+-- [E172] Type Error: tests/neg/i16453.scala:20:25 ---------------------------------------------------------------------
+20 |  implicitly[Option[Int]] // error
    |                         ^
-   |No given instance of type Option[Int] was found for parameter e of method implicitly in object Predef
-   |
-   |Note: implicit conversions are not automatically applied to arguments of using clauses. You will have to pass the argument explicitly.
-   |The following conversions in scope result in Option[Int]: 
-   |  - final given def given_Conversion_T_Option[T]: Conversion[T, Option[T]]
-   |  - implicit def toOption[T](t: T): Option[T]
+   |           No given instance of type Option[Int] was found for parameter e of method implicitly in object Predef

tests/neg/i16453.scala

@@ -3,7 +3,7 @@ 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)