Issue "search too large" as warnings that cannot be hidden

Author: odersky

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

@@ -175,7 +175,8 @@ enum ErrorMessageID extends java.lang.Enum[ErrorMessageID]:
     OverrideErrorID,
     MatchableWarningID,
     CannotExtendFunctionID,
-    LossyWideningConstantConversionID
+    LossyWideningConstantConversionID,
+    ImplicitSearchTooLargeID
 
   def errorNumber = ordinal - 2
 

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

@@ -124,6 +124,13 @@ abstract class Message(val errorId: ErrorMessageID) { self =>
     def explain    = self.explain ++ suffix
     override def canExplain = true
 
+  /** Override with `true` for messages that should always be shown even if their
+   *  position overlaps another messsage of a different class. On the other hand
+   *  multiple messages of the same class with overlapping positions will lead
+   *  to only a single message of that class to be issued.
+   */
+  def showAlways = false
+
   override def toString = msg
 }
 

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

@@ -10,19 +10,24 @@ import core.Contexts._
   * are suppressed, unless they are of increasing severity. */
 trait UniqueMessagePositions extends Reporter {
 
-  private val positions = new mutable.HashMap[(SourceFile, Int), Int]
+  private val positions = new mutable.HashMap[(SourceFile, Int), Diagnostic]
 
   /** Logs a position and returns true if it was already logged.
    *  @note  Two positions are considered identical for logging if they have the same point.
    */
   override def isHidden(dia: Diagnostic)(using Context): Boolean =
+    extension (dia1: Diagnostic) def hides(dia2: Diagnostic): Boolean =
+      if dia2.msg.showAlways then dia1.msg.getClass == dia2.msg.getClass
+      else dia1.level >= dia2.level
     super.isHidden(dia) || {
-      dia.pos.exists && !ctx.settings.YshowSuppressedErrors.value && {
+      dia.pos.exists
+      && !ctx.settings.YshowSuppressedErrors.value
+      && {
         var shouldHide = false
         for (pos <- dia.pos.start to dia.pos.end)
           positions get (ctx.source, pos) match {
-            case Some(level) if level >= dia.level => shouldHide = true
-            case _ => positions((ctx.source, pos)) = dia.level
+            case Some(dia1) if dia1.hides(dia) => shouldHide = true
+            case _ => positions((ctx.source, pos)) = dia
           }
         shouldHide
       }

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

@@ -2515,3 +2515,15 @@ import transform.SymUtils._
           |Inlining such definition would multiply this footprint for each call site.
           |""".stripMargin
   }
+
+  class ImplicitSearchTooLargeWarning(limit: Int)(using Context) extends TypeMsg(ImplicitSearchTooLargeID):
+    override def showAlways = true
+    def msg =
+      em"""Implicit search problem too large.
+          |an implicit search was terminated with failure after trying $limit expressions.
+          |
+          |You can change the behavior by setting the `-Ximplicit-search-limit` value.
+          |Smaller values cause the search to fail faster.
+          |Larger values might make a very large search problem succeed.
+          |"""
+    def explain = ""

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

@@ -1145,15 +1145,7 @@ trait Implicits:
         if result then
           var c = ctx
           while c.outer.typer eq ctx.typer do c = c.outer
-          report.echo(
-            em"""Implicit search problem too large.
-                |an implicit search was terminated with failure after trying $limit expressions.
-                |
-                |You can change the behavior by setting the `-Ximplicit-search-limit` value.
-                |Smaller values cause the search to fail faster.
-                |Larger values might make a very large search problem succeed.
-                |""",
-            ctx.source.atSpan(span))(using c)
+          report.warning(ImplicitSearchTooLargeWarning(limit), ctx.source.atSpan(span))(using c)
         else
           h.root.nestedSearches = nestedSearches + 1
         result

tests/neg-custom-args/i13838.check

@@ -16,3 +16,12 @@
   |
 
 longer explanation available when compiling with `-explain`
+-- [E168] Type Warning: tests/neg-custom-args/i13838.scala:8:50 --------------------------------------------------------
+8 |  def liftF[F[_], A](fa: F[A]): F[Foo[A]] = map(fa)(???)  // error
+  |                                                  ^
+  |                                     Implicit search problem too large.
+  |                                     an implicit search was terminated with failure after trying 1000 expressions.
+  |
+  |                                     You can change the behavior by setting the `-Ximplicit-search-limit` value.
+  |                                     Smaller values cause the search to fail faster.
+  |                                     Larger values might make a very large search problem succeed.