Do not visit args recursively in issueErrors

WojciechMazur · WojciechMazur · commit 4b84055e1273 · 2024-07-06T16:21:12.000+02:00
Instead, fix the display of nested `AmbiguousImplicits` errors. [Cherry-picked 0e4d51a][modified]
diff --git a/compiler/src/dotty/tools/dotc/reporting/messages.scala b/compiler/src/dotty/tools/dotc/reporting/messages.scala
@@ -2955,7 +2955,7 @@ class MissingImplicitArgument(
      *  def foo(implicit foo: Foo): Any = ???
      */
     arg.tpe match
-      case ambi: AmbiguousImplicits =>
+      case ambi: AmbiguousImplicits if !ambi.nested =>
         (ambi.alt1, ambi.alt2) match
           case (alt @ AmbiguousImplicitMsg(msg), _) =>
             userDefinedAmbiguousImplicitMsg(alt, msg)
diff --git a/compiler/src/dotty/tools/dotc/typer/Implicits.scala b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
@@ -514,7 +514,8 @@ object Implicits:
     override def toString = s"TooUnspecific"
 
   /** An ambiguous implicits failure */
-  class AmbiguousImplicits(val alt1: SearchSuccess, val alt2: SearchSuccess, val expectedType: Type, val argument: Tree) extends SearchFailureType {
+  class AmbiguousImplicits(val alt1: SearchSuccess, val alt2: SearchSuccess, val expectedType: Type, val argument: Tree, val nested: Boolean = false) extends SearchFailureType {
+
     def msg(using Context): Message =
       var str1 = err.refStr(alt1.ref)
       var str2 = err.refStr(alt2.ref)
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -3803,38 +3803,36 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
         end implicitArgs
 
         /** Reports errors for arguments of `appTree` that have a
-          * `SearchFailureType`, recursively traversing arguments that are
-          * themselves applications. `mt` must be the type of `appTree.fun`.
+          * `SearchFailureType`.
           */
-        def reportErrors(appTree: Apply, mt: MethodType): Unit =
-          val Apply(fun, args) = appTree
-          for (paramName, formal, arg) <- mt.paramNames.lazyZip(mt.paramInfos).lazyZip(args) do
+        def issueErrors(fun: Tree, args: List[Tree]): Tree =
+          def firstFailure = args.tpes.find(_.isInstanceOf[SearchFailureType]).getOrElse(NoType)
+          val errorType =
+            firstFailure match
+              case tp: AmbiguousImplicits =>
+                AmbiguousImplicits(tp.alt1, tp.alt2, tp.expectedType, tp.argument, nested = true)
+              case tp =>
+                tp
+          val res = untpd.Apply(fun, args).withType(errorType)
+
+          wtp.paramNames.lazyZip(wtp.paramInfos).lazyZip(args).foreach { (paramName, formal, arg) =>
             arg.tpe match
               case failure: SearchFailureType =>
-                arg match
-                  case childAppTree: Apply =>
-                    childAppTree.fun.tpe.widen match
-                      case childMt: MethodType => reportErrors(childAppTree, childMt)
-                      case _ => ()
-                  case _ => ()
-
                 val methodStr = err.refStr(methPart(fun).tpe)
                 val paramStr = implicitParamString(paramName, methodStr, fun)
-                val paramSymWithMethodCallTree =
-                  fun.symbol.paramSymss.flatten
-                    .find(_.name == paramName)
-                    .map((_, appTree))
-                val message = missingArgMsg(arg, formal, paramStr, paramSymWithMethodCallTree)
-                // Note: if the same error type appears on several trees, we
-                // might report it several times, but this is not a problem
-                // because only the first one will be displayed. We traverse in
-                // post-order, so that the most detailed message gets displayed.
-                report.error(message, fun.srcPos.endPos)
-              case _ => ()
+                val paramSym = fun.symbol.paramSymss.flatten.find(_.name == paramName)
+                val paramSymWithMethodCallTree = paramSym.map((_, res))
+                report.error(
+                   missingArgMsg(arg, formal, paramStr, paramSymWithMethodCallTree),
+                   tree.srcPos.endPos
+                 )
+              case _ =>
+          }
+
+          res
 
         val args = implicitArgs(wtp.paramInfos, 0, pt)
-        val firstFailure = args.tpes.find(_.isInstanceOf[SearchFailureType])
-        if (firstFailure.isDefined) {
+        if (args.tpes.exists(_.isInstanceOf[SearchFailureType])) {
           // If there are several arguments, some arguments might already
           // have influenced the context, binding variables, but later ones
           // might fail. In that case the constraint and instantiated variables
@@ -3862,14 +3860,9 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
             // node, we can report the errors for each argument nicely.
             // Otherwise, we don't report anything here.
             retyped match
-              case retyped: Apply if retyped.tpe.isError => reportErrors(retyped, wtp)
-              case _ => ()
-
-            retyped
-          else
-            val res = untpd.Apply(tree, args).withType(firstFailure.get)
-            reportErrors(res, wtp)
-            res
+              case Apply(tree, args) if retyped.tpe.isError => issueErrors(tree, args)
+              case _ => retyped
+          else issueErrors(tree, args)
         }
         else tree match {
           case tree: Block =>
diff --git a/tests/neg/19414-desugared.check b/tests/neg/19414-desugared.check
@@ -1,4 +1,14 @@
 -- [E172] Type Error: tests/neg/19414-desugared.scala:22:34 ------------------------------------------------------------
 22 |  summon[BodySerializer[JsObject]] // error: Ambiguous given instances
    |                                  ^
-   |Ambiguous given instances: both given instance given_Writer_JsValue and given instance given_Writer_JsObject match type Writer[B] of parameter writer of given instance given_BodySerializer_B
+   |No given instance of type BodySerializer[JsObject] was found for parameter x of method summon in object Predef.
+   |I found:
+   |
+   |    given_BodySerializer_B[B](
+   |      writer =
+   |        /* ambiguous: both given instance given_Writer_JsValue and given instance given_Writer_JsObject match type Writer[B] */
+   |          summon[Writer[B]]
+   |      ,
+   |    this.given_BodySerializer_B$default$2[B])
+   |
+   |But both given instance given_Writer_JsValue and given instance given_Writer_JsObject match type Writer[B].
diff --git a/tests/neg/19414.check b/tests/neg/19414.check
@@ -1,4 +1,14 @@
 -- [E172] Type Error: tests/neg/19414.scala:15:34 ----------------------------------------------------------------------
 15 |  summon[BodySerializer[JsObject]] // error: Ambiguous given instances
    |                                  ^
-   |Ambiguous given instances: both given instance given_Writer_JsValue and given instance given_Writer_JsObject match type Writer[B] of a context parameter of given instance given_BodySerializer_B
+   |No given instance of type BodySerializer[JsObject] was found for parameter x of method summon in object Predef.
+   |I found:
+   |
+   |    given_BodySerializer_B[B](
+   |      evidence$1 =
+   |        /* ambiguous: both given instance given_Writer_JsValue and given instance given_Writer_JsObject match type Writer[B] */
+   |          summon[Writer[B]]
+   |      ,
+   |    this.given_BodySerializer_B$default$2[B])
+   |
+   |But both given instance given_Writer_JsValue and given instance given_Writer_JsObject match type Writer[B].
diff --git a/tests/neg/given-ambiguous-1.check b/tests/neg/given-ambiguous-1.check
@@ -0,0 +1,9 @@
+-- [E172] Type Error: tests/neg/given-ambiguous-1.scala:12:23 ----------------------------------------------------------
+12 |def f: Unit = summon[B] // error: Ambiguous given instances
+   |                       ^
+   |                No given instance of type B was found for parameter x of method summon in object Predef.
+   |                I found:
+   |
+   |                    given_B(/* ambiguous: both given instance a1 and given instance a2 match type A */summon[A])
+   |
+   |                But both given instance a1 and given instance a2 match type A.
diff --git a/tests/neg/given-ambiguous-1.scala b/tests/neg/given-ambiguous-1.scala
@@ -0,0 +1,12 @@
+class A
+class B
+given a1: A = ???
+given a2: A = ???
+given (using a: A): B = ???
+
+// In this case, the ambiguous given instance is not directly the argument of
+// `summon`; it is the argument of `given_B` which is needed for the argument of
+// `summon`. This is a nested ambiguous implicit, thus we report an error in
+// the style "I found ... but". See `given-ambiguous-2` for a direct ambiguous
+// implicit error.
+def f: Unit = summon[B] // error: Ambiguous given instances
diff --git a/tests/neg/given-ambiguous-2.check b/tests/neg/given-ambiguous-2.check
@@ -0,0 +1,4 @@
+-- [E172] Type Error: tests/neg/given-ambiguous-2.scala:10:15 ----------------------------------------------------------
+10 |def f: Unit = g // error: Ambiguous given instances
+   |               ^
+   | Ambiguous given instances: both given instance a1 and given instance a2 match type A of parameter a of method g
diff --git a/tests/neg/given-ambiguous-2.scala b/tests/neg/given-ambiguous-2.scala
@@ -0,0 +1,10 @@
+class A
+class B
+given a1: A = ???
+given a2: A = ???
+def g(using a: A): B = ???
+
+// In this case, the ambiguous given instance is directly the argument of
+// `summon`. This is a direct ambiguous implicit, thus we report the error
+// directly. See `given-ambiguous-1` for a nested ambiguous implicit error.
+def f: Unit = g // error: Ambiguous given instances
diff --git a/tests/neg/given-ambiguous-default-1.check b/tests/neg/given-ambiguous-default-1.check
@@ -1,4 +1,9 @@
 -- [E172] Type Error: tests/neg/given-ambiguous-default-1.scala:18:23 --------------------------------------------------
 18 |def f: Unit = summon[B] // error: Ambiguous given instances
    |                       ^
-   |Ambiguous given instances: both given instance a1 and given instance a2 match type A of parameter a of given instance given_B
+   |            No given instance of type B was found for parameter x of method summon in object Predef.
+   |            I found:
+   |
+   |                given_B(a = /* ambiguous: both given instance a1 and given instance a2 match type A */summon[A])
+   |
+   |            But both given instance a1 and given instance a2 match type A.
diff --git a/tests/neg/given-ambiguous-default-2.check b/tests/neg/given-ambiguous-default-2.check
@@ -1,4 +1,9 @@
 -- [E172] Type Error: tests/neg/given-ambiguous-default-2.scala:18:23 --------------------------------------------------
 18 |def f: Unit = summon[C] // error: Ambiguous given instances
    |                       ^
-   |Ambiguous given instances: both given instance a1 and given instance a2 match type A of parameter a of given instance given_C
+   |No given instance of type C was found for parameter x of method summon in object Predef.
+   |I found:
+   |
+   |    given_C(a = /* ambiguous: both given instance a1 and given instance a2 match type A */summon[A], this.given_C$default$2)
+   |
+   |But both given instance a1 and given instance a2 match type A.
diff --git a/tests/neg/i8827a.check b/tests/neg/i8827a.check
@@ -1,7 +1,12 @@
 -- [E172] Type Error: tests/neg/i8827a.scala:16:26 ---------------------------------------------------------------------
 16 |  summon[Order[List[Foo]]] // error
    |                          ^
-   | No given instance of type pkg.Order[pkg.Foo] was found for parameter orderA of method orderList in object Order
+   | No given instance of type pkg.Order[List[pkg.Foo]] was found for parameter x of method summon in object Predef.
+   | I found:
+   |
+   |     pkg.Order.orderList[pkg.Foo](/* missing */summon[pkg.Order[pkg.Foo]])
+   |
+   | But no implicit values were found that match type pkg.Order[pkg.Foo].
    |
    | The following import might fix the problem:
    |
diff --git a/tests/neg/i8827b.check b/tests/neg/i8827b.check
@@ -1,7 +1,12 @@
 -- [E172] Type Error: tests/neg/i8827b.scala:16:28 ---------------------------------------------------------------------
 16 |  summon[Order[Option[Foo]]] // error
    |                            ^
-   |No given instance of type pkg.Order[pkg.Foo] was found for parameter orderA of given instance given_Order_Option in object Order
+   |No given instance of type pkg.Order[Option[pkg.Foo]] was found for parameter x of method summon in object Predef.
+   |I found:
+   |
+   |    pkg.Order.given_Order_Option[pkg.Foo](/* missing */summon[pkg.Order[pkg.Foo]])
+   |
+   |But no implicit values were found that match type pkg.Order[pkg.Foo].
    |
    |The following import might fix the problem:
    |
diff --git a/tests/neg/i9568.check b/tests/neg/i9568.check
@@ -4,10 +4,13 @@
    |          No given instance of type => Monad[F] was found for parameter ev of method blaMonad in object Test.
    |          I found:
    |
-   |              Test.blaMonad[F², S]
+   |              Test.blaMonad[F², S](Test.blaMonad[F³, S²])
    |
-   |          But method blaMonad in object Test does not match type => Monad[F]
+   |          But method blaMonad in object Test does not match type => Monad[F²]
    |
    |          where:    F  is a type variable with constraint <: [_] =>> Any
    |                    F² is a type variable with constraint <: [_] =>> Any
+   |                    F³ is a type variable with constraint <: [_] =>> Any
+   |                    S  is a type variable
+   |                    S² is a type variable
    |          .
diff --git a/tests/neg/implicitSearch.check b/tests/neg/implicitSearch.check
@@ -1,7 +1,12 @@
 -- [E172] Type Error: tests/neg/implicitSearch.scala:13:12 -------------------------------------------------------------
 13 |    sort(xs)  // error (with a partially constructed implicit argument shown)
    |            ^
-   |            No given instance of type Test.Ord[T] was found for parameter o of method listOrd in object Test
+   |      No given instance of type Test.Ord[List[List[T]]] was found for parameter o of method sort in object Test.
+   |      I found:
+   |
+   |          Test.listOrd[List[T]](Test.listOrd[T](/* missing */summon[Test.Ord[T]]))
+   |
+   |      But no implicit values were found that match type Test.Ord[T].
 -- [E172] Type Error: tests/neg/implicitSearch.scala:15:38 -------------------------------------------------------------
 15 |    listOrd(listOrd(implicitly[Ord[T]] /*not found*/)) // error
    |                                      ^
diff --git a/tests/neg/missing-implicit3.check b/tests/neg/missing-implicit3.check
@@ -1,9 +1,14 @@
 -- [E172] Type Error: tests/neg/missing-implicit3.scala:13:36 ----------------------------------------------------------
 13 |val sortedFoos = sort(List(new Foo)) // error
    |                                    ^
-   |No given instance of type ord.Foo => Comparable[? >: ord.Foo] was found for parameter x$1 of given instance ordered in object Ord
+   |     No given instance of type ord.Ord[ord.Foo] was found for a context parameter of method sort in package ord.
+   |     I found:
    |
-   |The following import might make progress towards fixing the problem:
+   |         ord.Ord.ordered[ord.Foo](/* missing */summon[ord.Foo => Comparable[? >: ord.Foo]])
    |
-   |  import scala.math.Ordered.orderingToOrdered
+   |     But no implicit values were found that match type ord.Foo => Comparable[? >: ord.Foo].
+   |
+   |     The following import might make progress towards fixing the problem:
+   |
+   |       import scala.math.Ordered.orderingToOrdered
    |

Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,12 @@`
`1`	`1`	`-- [E172] Type Error: tests/neg/i8827a.scala:16:26 ---------------------------------------------------------------------`
`2`	`2`	`16 \| summon[Order[List[Foo]]] // error`
`3`	`3`	`\| ^`
`4`		`- \| No given instance of type pkg.Order[pkg.Foo] was found for parameter orderA of method orderList in object Order`
	`4`	`+ \| No given instance of type pkg.Order[List[pkg.Foo]] was found for parameter x of method summon in object Predef.`
	`5`	`+ \| I found:`
	`6`	`+ \|`
	`7`	`+ \| pkg.Order.orderList[pkg.Foo](/* missing */summon[pkg.Order[pkg.Foo]])`
	`8`	`+ \|`
	`9`	`+ \| But no implicit values were found that match type pkg.Order[pkg.Foo].`
`5`	`10`	`\|`
`6`	`11`	`\| The following import might fix the problem:`
`7`	`12`	`\|`
Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,12 @@`
`1`	`1`	`-- [E172] Type Error: tests/neg/i8827b.scala:16:28 ---------------------------------------------------------------------`
`2`	`2`	`16 \| summon[Order[Option[Foo]]] // error`
`3`	`3`	`\| ^`
`4`		`- \|No given instance of type pkg.Order[pkg.Foo] was found for parameter orderA of given instance given_Order_Option in object Order`
	`4`	`+ \|No given instance of type pkg.Order[Option[pkg.Foo]] was found for parameter x of method summon in object Predef.`
	`5`	`+ \|I found:`
	`6`	`+ \|`
	`7`	`+ \| pkg.Order.given_Order_Option[pkg.Foo](/* missing */summon[pkg.Order[pkg.Foo]])`
	`8`	`+ \|`
	`9`	`+ \|But no implicit values were found that match type pkg.Order[pkg.Foo].`
`5`	`10`	`\|`
`6`	`11`	`\|The following import might fix the problem:`
`7`	`12`	`\|`
Original file line number	Diff line number	Diff line change
`@@ -4,10 +4,13 @@`
`4`	`4`	`\| No given instance of type => Monad[F] was found for parameter ev of method blaMonad in object Test.`
`5`	`5`	`\| I found:`
`6`	`6`	`\|`
`7`		`- \| Test.blaMonad[F², S]`
	`7`	`+ \| Test.blaMonad[F², S](Test.blaMonad[F³, S²])`
`8`	`8`	`\|`
`9`		`- \| But method blaMonad in object Test does not match type => Monad[F]`
	`9`	`+ \| But method blaMonad in object Test does not match type => Monad[F²]`
`10`	`10`	`\|`
`11`	`11`	`\| where: F is a type variable with constraint <: [_] =>> Any`
`12`	`12`	`\| F² is a type variable with constraint <: [_] =>> Any`
	`13`	`+ \| F³ is a type variable with constraint <: [_] =>> Any`
	`14`	`+ \| S is a type variable`
	`15`	`+ \| S² is a type variable`
`13`	`16`	`\| .`
Original file line number	Diff line number	Diff line change
`@@ -1,9 +1,14 @@`
`1`	`1`	`-- [E172] Type Error: tests/neg/missing-implicit3.scala:13:36 ----------------------------------------------------------`
`2`	`2`	`13 \|val sortedFoos = sort(List(new Foo)) // error`
`3`	`3`	`\| ^`
`4`		`- \|No given instance of type ord.Foo => Comparable[? >: ord.Foo] was found for parameter x$1 of given instance ordered in object Ord`
	`4`	`+ \| No given instance of type ord.Ord[ord.Foo] was found for a context parameter of method sort in package ord.`
	`5`	`+ \| I found:`
`5`	`6`	`\|`
`6`		`- \|The following import might make progress towards fixing the problem:`
	`7`	`+ \| ord.Ord.ordered[ord.Foo](/* missing */summon[ord.Foo => Comparable[? >: ord.Foo]])`
`7`	`8`	`\|`
`8`		`- \| import scala.math.Ordered.orderingToOrdered`
	`9`	`+ \| But no implicit values were found that match type ord.Foo => Comparable[? >: ord.Foo].`
	`10`	`+ \|`
	`11`	`+ \| The following import might make progress towards fixing the problem:`
	`12`	`+ \|`
	`13`	`+ \| import scala.math.Ordered.orderingToOrdered`
`9`	`14`	`\|`