Add verbose mode to WConf / nowarn to display matching message filters

In "verbose" mode warnings are printed with a list of matching message
filters that can be used in `-Wconf` and/or `@nowarn`. Example:

```
-- [E000] Syntax Warning: Test.scala:5:12 --------------------------------------
5 |  def bar = try 1
  |            ^^^^^
  |            A try without catch or finally is equivalent to putting
  |            its body in a block; no exceptions are handled.
Matching filters for @nowarn or -Wconf:
  - id=E0
  - name=EmptyCatchOrFinallyBlock

longer explanation available when compiling with `-explain`
```

Verbose mode can be enabled in `-Wconf`, for example for all warnings
using `-Wconf:any:v`.

Howeber, changing compiler flags is slow. To make the workflow more
convenient verbose mode can be enabled by annotating the surrounding
code with `@nowarn("verbose")` or `@nowarn("v")`:

```
  @nowarn("v")
  def bar = try 1
```

Author: lrytz

compiler/src/dotty/tools/dotc/Run.scala

@@ -16,7 +16,8 @@ import io.{AbstractFile, PlainFile, VirtualFile}
 import Phases.unfusedPhases
 
 import util._
-import reporting.{Reporter, Suppression}
+import reporting.{Reporter, Suppression, Action}
+import reporting.Diagnostic
 import reporting.Diagnostic.Warning
 import rewrites.Rewrites
 
@@ -110,10 +111,14 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
     def addSuspendedMessage(warning: Warning) =
       mySuspendedMessages.getOrElseUpdate(warning.pos.source, mutable.LinkedHashSet.empty) += warning
 
-    def isSuppressed(warning: Warning): Boolean =
-      mySuppressions.getOrElse(warning.pos.source, Nil).find(_.matches(warning)) match {
-        case Some(s) => s.markUsed(); true
-        case _ => false
+    def nowarnAction(dia: Diagnostic): Action.Warning.type | Action.Verbose.type | Action.Silent.type =
+      mySuppressions.getOrElse(dia.pos.source, Nil).find(_.matches(dia)) match {
+        case Some(s) =>
+          s.markUsed()
+          if (s.verbose) Action.Verbose
+          else Action.Silent
+        case _ =>
+          Action.Warning
       }
 
     def addSuppression(sup: Suppression): Unit =

compiler/src/dotty/tools/dotc/config/ScalaSettings.scala

@@ -152,9 +152,14 @@ private sealed trait WarningSettings:
          |  - Message id: id=E129
          |    The message id is printed with the warning.
          |
+         |In verbose warning mode the compiler prints matching filters for warnings.
+         |Verbose mode can be enabled globally using `-Wconf:any:verbose`, or locally
+         |using the @nowarn annotation (example: `@nowarn("v") def test = try 1`).
+         |
          |<action>
          |  - error / e
          |  - warning / w
+         |  - verbose / v (emit warning, show additional help for writing `-Wconf` filters)
          |  - info / i    (infos are not counted as warnings and not affected by `-Werror`)
          |  - silent / s
          |

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

@@ -2,12 +2,13 @@ package dotty.tools
 package dotc
 package reporting
 
-import util.SourcePosition
-import core.Contexts._
-import config.Settings.Setting
-import interfaces.Diagnostic.{ERROR, INFO, WARNING}
+import dotty.tools.dotc.config.Settings.Setting
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.interfaces.Diagnostic.{ERROR, INFO, WARNING}
+import dotty.tools.dotc.util.SourcePosition
 
 import java.util.Optional
+import scala.util.chaining._
 
 object Diagnostic:
 
@@ -35,8 +36,8 @@ object Diagnostic:
     msg: Message,
     pos: SourcePosition
   ) extends Diagnostic(msg, pos, WARNING) {
-    def toError: Error = new Error(msg, pos)
-    def toInfo: Info = new Info(msg, pos)
+    def toError: Error = new Error(msg, pos).tap(e => if isVerbose then e.setVerbose())
+    def toInfo: Info = new Info(msg, pos).tap(e => if isVerbose then e.setVerbose())
     def isSummarizedConditional(using Context): Boolean = false
   }
 
@@ -84,6 +85,12 @@ class Diagnostic(
   val pos: SourcePosition,
   val level: Int
 ) extends Exception with interfaces.Diagnostic:
+  private var verbose: Boolean = false
+  def isVerbose: Boolean = verbose
+  def setVerbose(): this.type =
+    verbose = true
+    this
+
   override def position: Optional[interfaces.SourcePosition] =
     if (pos.exists && pos.source.exists) Optional.of(pos) else Optional.empty()
   override def message: String =

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

@@ -142,6 +142,22 @@ trait MessageRendering {
     sb.toString
   }
 
+  def appendFilterHelp(dia: Diagnostic, sb: mutable.StringBuilder): Unit =
+    import dia._
+    val hasId = msg.errorId.errorNumber >= 0
+    val category = dia match {
+      case _: UncheckedWarning => "unchecked"
+      case _: DeprecationWarning => "deprecation"
+      case _: FeatureWarning => "feature"
+      case _ => ""
+    }
+    if (hasId || category.nonEmpty)
+      sb.append(EOL).append("Matching filters for @nowarn or -Wconf:")
+      if (hasId)
+        sb.append(EOL).append("  - id=E").append(msg.errorId.errorNumber)
+      if (category.nonEmpty)
+        sb.append(EOL).append("  - cat=").append(category)
+
   /** The whole message rendered from `msg` */
   def messageAndPos(dia: Diagnostic)(using Context): String = {
     import dia._
@@ -160,6 +176,8 @@ trait MessageRendering {
       else sb.append(msg.message)
     }
     else sb.append(msg.message)
+    if (dia.isVerbose)
+      appendFilterHelp(dia, sb)
     sb.toString
   }
 

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

@@ -2,20 +2,19 @@ package dotty.tools
 package dotc
 package reporting
 
+import dotty.tools.dotc.ast.{Trees, tpd}
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.core.Decorators._
+import dotty.tools.dotc.core.Mode
+import dotty.tools.dotc.core.Symbols.{NoSymbol, Symbol}
+import dotty.tools.dotc.reporting.Diagnostic._
+import dotty.tools.dotc.reporting.Message._
+import dotty.tools.dotc.util.NoSourcePosition
+
+import java.io.{BufferedReader, PrintWriter}
 import scala.annotation.internal.sharable
-
-import core.Contexts._
-import core.Decorators._
-import collection.mutable
-import core.Mode
-import dotty.tools.dotc.core.Symbols.{Symbol, NoSymbol}
-import Diagnostic._
-import ast.{tpd, Trees}
-import Message._
-import core.Decorators._
-import util.NoSourcePosition
-
-import java.io.{ BufferedReader, PrintWriter }
+import scala.collection.mutable
+import scala.util.chaining._
 
 object Reporter {
   /** Convert a SimpleReporter into a real Reporter */
@@ -142,12 +141,13 @@ abstract class Reporter extends interfaces.ReporterResult {
 
       val toReport = dia match
         case w: Warning =>
+          def fatal(w: Warning) = if ctx.settings.XfatalWarnings.value && !w.isSummarizedConditional then Some(w.toError) else Some(w)
           if ctx.settings.silentWarnings.value then None
-          else if ctx.settings.XfatalWarnings.value && !w.isSummarizedConditional then Some(w.toError)
           else WConf.parsed.action(dia) match
             case Silent  => None
             case Info    => Some(w.toInfo)
-            case Warning => Some(w)
+            case Warning => fatal(w)
+            case Verbose => fatal(w).tap(_.foreach(_.setVerbose()))
             case Error   => Some(w.toError)
         case _ => Some(dia)
 
@@ -173,8 +173,10 @@ abstract class Reporter extends interfaces.ReporterResult {
     dia match
       case w: Warning if ctx.run != null =>
         val sup = ctx.run.suppressions
-        if sup.suppressionsComplete(w.pos.source) then
-          if !sup.isSuppressed(w) then go()
+        if sup.suppressionsComplete(w.pos.source) then sup.nowarnAction(w) match
+          case Action.Warning => go()
+          case Action.Verbose => w.setVerbose(); go()
+          case Action.Silent =>
         else
           sup.addSuspendedMessage(w)
       case _ => go()

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

@@ -27,7 +27,7 @@ enum MessageFilter:
   case MessageID(errorId: ErrorMessageID)
 
 enum Action:
-  case Error, Warning, Info, Silent
+  case Error, Warning, Verbose, Info, Silent
 
 final case class WConf(confs: List[(List[MessageFilter], Action)]):
   def action(message: Diagnostic): Action = confs.collectFirst {
@@ -43,6 +43,7 @@ object WConf:
   def parseAction(s: String): Either[List[String], Action] = s match {
     case "error" | "e"            => Right(Error)
     case "warning" | "w"          => Right(Warning)
+    case "verbose" | "v"          => Right(Verbose)
     case "info" | "i"             => Right(Info)
     case "silent" | "s"           => Right(Silent)
     case _                        => Left(List(s"unknown action: `$s`"))
@@ -107,12 +108,12 @@ object WConf:
       else Right(WConf(fs))
     }
 
-case class Suppression(annotPos: SourcePosition, filters: List[MessageFilter], start: Int, end: Int):
+case class Suppression(annotPos: SourcePosition, filters: List[MessageFilter], start: Int, end: Int, verbose: Boolean):
   private[this] var _used = false
   def used: Boolean = _used
   def markUsed(): Unit = { _used = true }
 
   def matches(dia: Diagnostic): Boolean = {
     val pos = dia.pos
-    pos.exists && start <= pos.start && pos.end <= end && filters.forall(_.matches(dia))
+    pos.exists && start <= pos.start && pos.end <= end && (verbose || filters.forall(_.matches(dia)))
   }

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

@@ -2116,6 +2116,7 @@ class Typer extends Namer
   def registerNowarn(tree: Tree, mdef: untpd.Tree)(using Context): Unit =
     val annot = Annotations.Annotation(tree)
     def argPos = annot.argument(0).getOrElse(tree).sourcePos
+    var verbose = false
     val filters =
       if annot.arguments.isEmpty then List(MessageFilter.Any)
       else annot.argumentConstantString(0) match
@@ -2124,17 +2125,19 @@ class Typer extends Namer
           case _ =>
             report.warning(s"filter needs to be a compile-time constant string", argPos)
             Nil
+        case Some("") => Nil
+        case Some("verbose") | Some("v") =>
+          verbose = true
+          Nil
         case Some(s) =>
-          if s.isEmpty then Nil
+          val (ms, fs) = s.split('&').map(WConf.parseFilter).toList.partitionMap(identity)
+          if ms.nonEmpty then
+            report.warning(s"Invalid message filter\n${ms.mkString("\n")}", argPos)
+            List(MessageFilter.None)
           else
-            val (ms, fs) = s.split('&').map(WConf.parseFilter).toList.partitionMap(identity)
-            if ms.nonEmpty then
-              report.warning(s"Invalid message filter\n${ms.mkString("\n")}", argPos)
-              List(MessageFilter.None)
-            else
-              fs
+            fs
     val range = mdef.sourcePos
-    ctx.run.suppressions.addSuppression(Suppression(tree.sourcePos, filters, range.start, range.end))
+    ctx.run.suppressions.addSuppression(Suppression(tree.sourcePos, filters, range.start, range.end, verbose))
 
   def typedValDef(vdef: untpd.ValDef, sym: Symbol)(using Context): Tree = {
     val ValDef(name, tpt, _) = vdef