Fix inversion of if, check for errors properly

Author: ysthakur

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

@@ -2750,7 +2750,7 @@ class MissingImplicitArgument(
           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}:" +
+            i"The following implicits in scope can be implicitly converted to ${pt.show}:" +
             ignoredConvertibleImplicits.map { imp => s"\n- ${imp.symbol.showDcl}"}.mkString
           )
         super.msgPostscript

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

@@ -928,44 +928,46 @@ trait Implicits:
       else currImplicits.refs ::: allImplicits(currImplicits.outerImplicits)
 
     /** Ensure an implicit is not a Scala 2-style implicit conversion, based on its type */
-    def notImplicitConv(typ: Type): Boolean = typ match {
-      case PolyType(_, resType) => notImplicitConv(resType)
-      case mt: MethodType => mt.isImplicitMethod || mt.isContextualMethod
-      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 mt: MethodType => !mt.isImplicitMethod && !mt.isContextualMethod
       case _ => false
     }
 
-    def ignoredConversions = arg.tpe match
+    def hasErrors(tree: Tree): Boolean =
+      if tree.tpe.isInstanceOf[ErrorType] then true
+      else
+        tree match {
+          case Apply(_, List(arg)) => arg.tpe.isInstanceOf[ErrorType]
+          case _ => false
+        }
+
+    def ignoredConvertibleImplicits = 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
+          // Get every implicit in scope and try to convert each
           allImplicits(ctx.implicits)
+            .distinctBy(_.underlyingRef.denot)
+            .view
             .map(_.underlyingRef)
             .filter { imp =>
-              if notImplicitConv(imp.underlying) then false
+              if isScala2Conv(imp.underlying) || imp.symbol == defn.Predef_conforms then
+                false
               else
-                val locked = ctx.typerState.ownedVars
-                val tryCtx = ctx.fresh
+                // Using Mode.Printing will stop it from printing errors
                 val tried = Contexts.withMode(Mode.Printing) {
                     typed(
                       tpd.ref(imp).withSpan(arg.span),
                       fail.expectedType,
-                      locked
+                      ctx.typerState.ownedVars
                     )
-                  }(using tryCtx)
-                !tryCtx.reporter.hasErrors && fail.expectedType =:= tried.tpe
+                  }
+                !hasErrors(tried) && fail.expectedType =:= tried.tpe
             }
         else
           Nil
 
-    MissingImplicitArgument(arg, pt, where, paramSymWithMethodCallTree, ignoredInstanceNormalImport, ignoredConversions)
+    MissingImplicitArgument(arg, pt, where, paramSymWithMethodCallTree, ignoredInstanceNormalImport, ignoredConvertibleImplicits)
   }
 
   /** A string indicating the formal parameter corresponding to a  missing argument */

tests/neg/i16453.check

@@ -1,12 +1,45 @@
--- [E172] Type Error: tests/neg/i16453.scala:19:21 ---------------------------------------------------------------------
-19 |  summon[Option[Int]] // error
+-- [E172] Type Error: tests/neg/i16453.scala:21:19 ---------------------------------------------------------------------
+21 |  summon[List[Int]] // error
+   |                   ^
+   |                 No given instance of type List[Int] was found for parameter x of method summon in object Predef
+-- [E172] Type Error: tests/neg/i16453.scala:23:21 ---------------------------------------------------------------------
+23 |  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 can be converted to Option[Int]:
-   |- given bar: Int
--- [E172] Type Error: tests/neg/i16453.scala:20:25 ---------------------------------------------------------------------
-20 |  implicitly[Option[Int]] // error
+   |The following implicits in scope can be implicitly converted to Option[Int]:
+   |- final lazy given val baz3: Char
+   |- final lazy given val bar3: Int
+-- [E172] Type Error: tests/neg/i16453.scala:24:26 ---------------------------------------------------------------------
+24 |  implicitly[Option[Char]] // error
+   |                          ^
+   |No given instance of type Option[Char] 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 implicits in scope can be implicitly converted to Option[Char]:
+   |- final lazy given val baz3: Char
+-- [E172] Type Error: tests/neg/i16453.scala:25:20 ---------------------------------------------------------------------
+25 |  implicitly[String] // error
+   |                    ^
+   |No given instance of type String 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 implicits in scope can be implicitly converted to String:
+   |- final lazy given val baz3: Char
+-- [E172] Type Error: tests/neg/i16453.scala:35:16 ---------------------------------------------------------------------
+35 |  summon[String] // error
+   |                ^
+   |No given instance of type String 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 implicits in scope can be implicitly converted to String:
+   |- implicit val baz2: Char
+-- [E172] Type Error: tests/neg/i16453.scala:36:25 ---------------------------------------------------------------------
+36 |  implicitly[Option[Int]] // error
    |                         ^
-   |           No given instance of type Option[Int] was found for parameter e of method implicitly in object Predef
+   |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 implicits in scope can be implicitly converted to Option[Int]:
+   |- implicit val bar2: Int

tests/neg/i16453.scala

@@ -2,20 +2,36 @@ import scala.language.implicitConversions
 
 trait Foo { type T }
 
-// Scala 3 style conversion
-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]] = ???
+given irrelevant: Long = ???
+
+/** Use Scala 3 givens/conversions */
+def testScala3() = {
+  given c1[T]: Conversion[T, Option[T]] = ???
+  given c2[F <: Foo](using f: F): Conversion[f.T, Option[f.T]] = ???
+  given Conversion[Char, String] = ???
+  given Conversion[Char, Option[Int]] = ???
 
-def test() = {
   given foo: Foo with
     type T = Int
-  given bar: Int = 0
+  given bar3: Int = 0
+  given baz3: Char = 'a'
+
+  // This should get the usual error
+  summon[List[Int]] // error
 
   summon[Option[Int]] // error
+  implicitly[Option[Char]] // error
+  implicitly[String] // error
+}
+
+/** Use Scala 2 implicits */
+def testScala2() = {
+  implicit def toOpt[T](t: T): Option[T] = ???
+  implicit def char2Str(c: Char): String = ???
+  implicit val bar2: Int = 1
+  implicit val baz2: Char = 'b'
+
+  summon[String] // error
   implicitly[Option[Int]] // error
 }