Fix scala#10810: Better error diagnostics for extension methods

We gave misleading diagnostic before in the case where no extension
method was found since a TypeError was thrown.

Author: odersky

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

@@ -13,6 +13,7 @@ import util.SrcPos
 import config.Feature
 import java.util.regex.Matcher.quoteReplacement
 import reporting._
+import collection.mutable
 
 import scala.util.matching.Regex
 
@@ -143,23 +144,32 @@ object ErrorReporting {
     def selectErrorAddendum
       (tree: untpd.RefTree, qual1: Tree, qualType: Type, suggestImports: Type => String)
       (using Context): String =
-      val attempts: List[Tree] = qual1.getAttachment(Typer.HiddenSearchFailure) match
+      val attempts = mutable.ListBuffer[Tree]()
+      val nested = mutable.ListBuffer[NestedFailure]()
+      qual1.getAttachment(Typer.HiddenSearchFailure) match
         case Some(failures) =>
-          for failure <- failures
-              if !failure.reason.isInstanceOf[Implicits.NoMatchingImplicits]
-          yield failure.tree
-        case _ => Nil
+          for failure <- failures do
+            failure.reason match
+              case fail: NestedFailure => nested += fail
+              case fail: Implicits.NoMatchingImplicits => // do nothing
+              case _ => attempts += failure.tree
+        case _ =>
       if qualType.derivesFrom(defn.DynamicClass) then
         "\npossible cause: maybe a wrong Dynamic method signature?"
       else if attempts.nonEmpty then
-        val attemptStrings = attempts.map(_.showIndented(4)).distinct
+        val attemptStrings = attempts.toList.map(_.showIndented(4)).distinct
         val extMethods =
           if attemptStrings.length > 1 then "Extension methods were"
           else "An extension method was"
         i""".
            |$extMethods tried, but could not be fully constructed:
            |
            |    $attemptStrings%\nor\n    %"""
+      else if nested.nonEmpty then
+        i""".
+           |Extension methods were tried, but the search failed with:
+           |
+           |    ${nested.head.explanation}"""
       else if tree.hasAttachment(desugar.MultiLineInfix) then
         i""".
            |Note that `${tree.name}` is treated as an infix operator in Scala 3.

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

@@ -513,9 +513,19 @@ object Implicits:
       em"${err.refStr(ref)} produces a diverging implicit search when trying to $qualify"
   }
 
+  /** A search failure type for attempted ill-typed extension method calls */
   class FailedExtension(extApp: Tree, val expectedType: Type) extends SearchFailureType:
     def argument = EmptyTree
     def explanation(using Context) = em"$extApp does not $qualify"
+
+   /** A search failure type for aborted searches of extension methods, typically
+    *  because of a cyclic reference or similar.
+    */
+  class NestedFailure(_msg: Message, val expectedType: Type) extends SearchFailureType:
+    def argument = EmptyTree
+    override def msg(using Context) = _msg
+    def explanation(using Context) = msg.toString
+
 end Implicits
 
 import Implicits._

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

@@ -3496,24 +3496,29 @@ class Typer extends Namer
       // try an extension method in scope
       pt match {
         case selProto @ SelectionProto(selName: TermName, mbrType, _, _) =>
+
           def tryExtension(using Context): Tree =
-            try
-              findRef(selName, WildcardType, ExtensionMethod, EmptyFlags, tree.srcPos) match
+            findRef(selName, WildcardType, ExtensionMethod, EmptyFlags, tree.srcPos) match
+              case ref: TermRef =>
+                extMethodApply(untpd.ref(ref).withSpan(tree.span), tree, mbrType)
+              case _ => findRef(selProto.extensionName, WildcardType, ExtensionMethod, EmptyFlags, tree.srcPos) match
                 case ref: TermRef =>
                   extMethodApply(untpd.ref(ref).withSpan(tree.span), tree, mbrType)
-                case _ => findRef(selProto.extensionName, WildcardType, ExtensionMethod, EmptyFlags, tree.srcPos) match
-                  case ref: TermRef =>
-                    extMethodApply(untpd.ref(ref).withSpan(tree.span), tree, mbrType)
-                  case _ => EmptyTree
-            catch case ex: TypeError => errorTree(tree, ex, tree.srcPos)
-          val nestedCtx = ctx.fresh.setNewTyperState()
-          val app = tryExtension(using nestedCtx)
-          if (!app.isEmpty && !nestedCtx.reporter.hasErrors) {
-            nestedCtx.typerState.commit()
-            return ExtMethodApply(app)
-          }
-          else if !app.isEmpty then
-            rememberSearchFailure(tree, SearchFailure(app.withType(FailedExtension(app, pt))))
+                case _ => EmptyTree
+
+          try
+            val nestedCtx = ctx.fresh.setNewTyperState()
+            val app = tryExtension(using nestedCtx)
+            if !app.isEmpty then
+              if !nestedCtx.reporter.hasErrors then
+                nestedCtx.typerState.commit()
+                return ExtMethodApply(app)
+              else
+                rememberSearchFailure(tree,
+                  SearchFailure(app.withType(FailedExtension(app, pt))))
+          catch case ex: TypeError =>
+            rememberSearchFailure(tree,
+              SearchFailure(tree.withType(NestedFailure(ex.toMessage, pt))))
         case _ =>
       }
 

tests/neg/i10810.check

@@ -0,0 +1,7 @@
+-- [E008] Not Found Error: tests/neg/i10810.scala:10:16 ----------------------------------------------------------------
+10 |    def x = b.a.x  // error
+   |            ^^^^^
+   |            value x is not a member of A.
+   |            Extension methods were tried, but the search failed with:
+   |
+   |                Overloaded or recursive method x needs return type

tests/neg/i10810.scala

@@ -0,0 +1,11 @@
+final case class A()
+final case class B(a:A)
+
+object Test:
+
+  extension(a:A)
+    def x = 5
+
+  extension(b:B)
+    def x = b.a.x  // error
+