Fix #9185: Look at multiple search failures when trying an extension method

Also: change `implicitly[...]` to `summon[...]` in error message and
issue "extension method was tried" addendums also when no implicits were
searched.

Author: odersky

compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala

@@ -351,7 +351,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
       case id: Trees.SearchFailureIdent[?] =>
         tree.typeOpt match {
           case reason: Implicits.SearchFailureType =>
-            toText(id.name) ~ "implicitly[" ~ toText(reason.clarify(reason.expectedType)) ~ "]"
+            toText(id.name) ~ "summon[" ~ toText(reason.clarify(reason.expectedType)) ~ "]"
           case _ =>
             toText(id.name)
         }

compiler/src/dotty/tools/dotc/printing/Showable.scala

@@ -22,6 +22,11 @@ trait Showable extends Any {
   /** The string representation of this showable element. */
   def show(implicit ctx: Context): String = toText(ctx.printer).show
 
+  /** The string representation with each line after the first one indented
+   *  by the given given margin (in spaces).
+   */
+  def showIndented(margin: Int)(using Context): String = show.replace("\n", "\n" + " " * margin)
+
   /** The summarized string representation of this showable element.
    *  Recursion depth is limited to some smallish value. Default is
    *  Config.summarizeDepth.

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

@@ -478,6 +478,10 @@ object Implicits {
     def explanation(using Context): String =
       em"${err.refStr(ref)} produces a diverging implicit search when trying to $qualify"
   }
+
+  class FailedExtension(extApp: Tree, val expectedType: Type) extends SearchFailureType:
+    def argument = EmptyTree
+    def explanation(using Context) = em"$extApp does not $qualify"
 }
 
 import Implicits._

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

@@ -151,27 +151,36 @@ trait TypeAssigner {
     else {
       val kind = if (name.isTypeName) "type" else "value"
       def addendum =
-        if (qualType.derivesFrom(defn.DynamicClass))
+        val attempts: List[Tree] = qual1.getAttachment(Typer.HiddenSearchFailure) match
+          case Some(failures) =>
+            for failure <- failures
+                if !failure.reason.isInstanceOf[Implicits.NoMatchingImplicits]
+            yield failure.tree
+          case _ => Nil
+        if qualType.derivesFrom(defn.DynamicClass) then
           "\npossible cause: maybe a wrong Dynamic method signature?"
-        else qual1.getAttachment(Typer.HiddenSearchFailure) match
-          case Some(failure) if !failure.reason.isInstanceOf[Implicits.NoMatchingImplicits] =>
-            i""".
-              |An extension method was tried, but could not be fully constructed:
-              |
-              |    ${failure.tree.show.replace("\n", "\n    ")}"""
-          case _ =>
-            if (tree.hasAttachment(desugar.MultiLineInfix))
-              i""".
-                 |Note that `$name` is treated as an infix operator in Scala 3.
-                 |If you do not want that, insert a `;` or empty line in front
-                 |or drop any spaces behind the operator."""
-            else if qualType.isBottomType then ""
-            else
-              var add = importSuggestionAddendum(
-                ViewProto(qualType.widen,
-                  SelectionProto(name, WildcardType, NoViewsAllowed, privateOK = false)))
-              if add.isEmpty then ""
-              else ", but could be made available as an extension method." ++ add
+        else if attempts.nonEmpty then
+          val extMethods =
+            if attempts.length > 1 then "Extension methods were"
+            else "An extension method was"
+          val attemptStrings = attempts.map(_.showIndented(4))
+          i""".
+            |$extMethods tried, but could not be fully constructed:
+            |
+            |    $attemptStrings%\nor\n    %"""
+        else if tree.hasAttachment(desugar.MultiLineInfix) then
+          i""".
+              |Note that `$name` is treated as an infix operator in Scala 3.
+              |If you do not want that, insert a `;` or empty line in front
+              |or drop any spaces behind the operator."""
+        else if qualType.isBottomType then
+          ""
+        else
+          val add = importSuggestionAddendum(
+            ViewProto(qualType.widen,
+              SelectionProto(name, WildcardType, NoViewsAllowed, privateOK = false)))
+          if add.isEmpty then ""
+          else ", but could be made available as an extension method." ++ add
       end addendum
       errorType(NotAMember(qualType, name, kind, addendum), tree.sourcePos)
     }

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

@@ -79,7 +79,12 @@ object Typer {
   /** An attachment that indicates a failed conversion or extension method
    *  search was tried on a tree. This will in some cases be reported in error messages
    */
-  private[typer] val HiddenSearchFailure = new Property.Key[SearchFailure]
+  private[typer] val HiddenSearchFailure = new Property.Key[List[SearchFailure]]
+
+  /** Add `fail` to the list of search failures attached to `tree` */
+  def rememberSearchFailure(tree: tpd.Tree, fail: SearchFailure) =
+    tree.putAttachment(HiddenSearchFailure,
+      fail :: tree.attachmentOrElse(HiddenSearchFailure, Nil))
 }
 class Typer extends Namer
                with TypeAssigner
@@ -3393,6 +3398,8 @@ class Typer extends Namer
             nestedCtx.typerState.commit()
             return ExtMethodApply(app)
           }
+          else if !app.isEmpty then
+            rememberSearchFailure(tree, SearchFailure(app.withType(FailedExtension(app, pt))))
         case _ =>
       }
 
@@ -3417,7 +3424,7 @@ class Typer extends Namer
               // will cause a failure at the next level out, which usually gives
               // a better error message. To compensate, store the encountered failure
               // as an attachment, so that it can be reported later as an addendum.
-              tree.putAttachment(HiddenSearchFailure, failure)
+              rememberSearchFailure(tree, failure)
               tree
             }
             else recover(failure.reason)

tests/neg/i9185.check

@@ -0,0 +1,18 @@
+-- [E008] Not Found Error: tests/neg/i9185.scala:7:21 ------------------------------------------------------------------
+7 |  val value2 = "ola".pure  // error
+  |               ^^^^^^^^^^
+  |               value pure is not a member of String.
+  |               An extension method was tried, but could not be fully constructed:
+  |
+  |                   M.pure[A, F]("ola")(/* ambiguous */summon[M[F]])
+-- Error: tests/neg/i9185.scala:8:26 -----------------------------------------------------------------------------------
+8 |  val value3 = pure("ola") // error
+  |                          ^
+  |ambiguous implicit arguments: both object listMonad in object M and object optionMonad in object M match type M[F] of parameter m of method pure in object M
+-- [E008] Not Found Error: tests/neg/i9185.scala:11:16 -----------------------------------------------------------------
+11 |  val l = "abc".len  // error
+   |          ^^^^^^^^^
+   |          value len is not a member of String.
+   |          An extension method was tried, but could not be fully constructed:
+   |
+   |              M.len("abc")

tests/neg/i9185.scala

@@ -0,0 +1,12 @@
+trait M[F[_]] { def pure[A](x: A): F[A] }
+object M {
+  def [A, F[A]](x: A).pure(using m: M[F]): F[A] = m.pure(x)
+  given listMonad as M[List] { def pure[A](x: A): List[A] = List(x) }
+  given optionMonad as M[Option] { def pure[A](x: A): Option[A] = Some(x) }
+  val value1: List[String] = "ola".pure
+  val value2 = "ola".pure  // error
+  val value3 = pure("ola") // error
+
+  def (x: Int).len: Int = x
+  val l = "abc".len  // error
+}

tests/neg/implicitSearch.check

@@ -4,7 +4,7 @@
    |   no implicit argument of type Test.Ord[List[List[T]]] was found for parameter o of method sort in object Test.
    |   I found:
    |
-   |       Test.listOrd[T](Test.listOrd[T](/* missing */implicitly[Test.Ord[T]]))
+   |       Test.listOrd[T](Test.listOrd[T](/* missing */summon[Test.Ord[T]]))
    |
    |   But no implicit values were found that match type Test.Ord[T].
 -- Error: tests/neg/implicitSearch.scala:15:38 -------------------------------------------------------------------------

tests/neg/missing-implicit3.check

@@ -4,6 +4,6 @@
    |no implicit argument of type ord.Ord[ord.Foo] was found for an implicit parameter of method sort in package ord.
    |I found:
    |
-   |    ord.Ord.ordered[A](/* missing */implicitly[ord.Foo => Comparable[? >: ord.Foo]])
+   |    ord.Ord.ordered[A](/* missing */summon[ord.Foo => Comparable[? >: ord.Foo]])
    |
    |But no implicit values were found that match type ord.Foo => Comparable[? >: ord.Foo].