support @nowarn annotation

Author: lrytz

Diff for: compiler/src/dotty/tools/dotc/Run.scala

@@ -16,7 +16,8 @@ import io.{AbstractFile, PlainFile, VirtualFile}
 import Phases.unfusedPhases
 
 import util._
-import reporting.Reporter
+import reporting.{Reporter, Suppression}
+import reporting.Diagnostic.Warning
 import rewrites.Rewrites
 
 import profile.Profiler
@@ -96,6 +97,37 @@ class Run(comp: Compiler, ictx: Context) extends ImplicitRunInfo with Constraint
   private var myUnitsCached: List[CompilationUnit] = _
   private var myFiles: Set[AbstractFile] = _
 
+  // `@nowarn` annotations by source file, populated during typer
+  private val mySuppressions: mutable.LinkedHashMap[SourceFile, mutable.ListBuffer[Suppression]] = mutable.LinkedHashMap.empty
+  // source files whose `@nowarn` annotations are processed
+  private val mySuppressionsComplete: mutable.Set[SourceFile] = mutable.Set.empty
+  // warnings issued before a source file's `@nowarn` annotations are processed, suspended so that `@nowarn` can filter them
+  private val mySuspendedMessages: mutable.LinkedHashMap[SourceFile, mutable.LinkedHashSet[Warning]] = mutable.LinkedHashMap.empty
+
+  object suppressions:
+    def suppressionsComplete(source: SourceFile) = mySuppressionsComplete(source)
+
+    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 addSuppression(sup: Suppression): Unit =
+      val source = sup.annotPos.source
+      mySuppressions.getOrElseUpdate(source, mutable.ListBuffer.empty) += sup
+
+    def reportSuspendedMessages(unit: CompilationUnit)(using Context): Unit = {
+      // sort suppressions. they are not added in any particular order because of lazy type completion
+      for (sups <- mySuppressions.get(unit.source))
+        mySuppressions(unit.source) = sups.sortBy(sup => 0 - sup.start)
+      mySuppressionsComplete += unit.source
+      mySuspendedMessages.remove(unit.source).foreach(_.foreach(ctx.reporter.issueIfNotSuppressed))
+    }
+
   /** The compilation units currently being compiled, this may return different
    *  results over time.
    */

Diff for: compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -896,6 +896,7 @@ class Definitions {
   @tu lazy val InvariantBetweenAnnot: ClassSymbol = requiredClass("scala.annotation.internal.InvariantBetween")
   @tu lazy val MainAnnot: ClassSymbol = requiredClass("scala.main")
   @tu lazy val MigrationAnnot: ClassSymbol = requiredClass("scala.annotation.migration")
+  @tu lazy val NowarnAnnot: ClassSymbol = requiredClass("scala.annotation.nowarn")
   @tu lazy val TransparentTraitAnnot: ClassSymbol = requiredClass("scala.annotation.transparentTrait")
   @tu lazy val NativeAnnot: ClassSymbol = requiredClass("scala.native")
   @tu lazy val RepeatedAnnot: ClassSymbol = requiredClass("scala.annotation.internal.Repeated")

Diff for: compiler/src/dotty/tools/dotc/reporting/Reporter.scala

@@ -140,23 +140,19 @@ abstract class Reporter extends interfaces.ReporterResult {
 
   var unreportedWarnings: Map[String, Int] = Map.empty
 
-  def report(dia: Diagnostic)(using Context): Unit =
-    import Action._
-    val toReport = dia match {
-      case w: Warning => WConf.parsed.action(dia) match {
-        case Silent  => None
-        case Info    => Some(w.toInfo)
-        case Warning => Some(w)
-        case Error   => Some(w.toError)
+  def issueIfNotSuppressed(dia: Diagnostic)(using Context): Unit =
+    def go() =
+      import Action._
+      val toReport = dia match {
+        case w: Warning => WConf.parsed.action(dia) match {
+          case Silent  => None
+          case Info    => Some(w.toInfo)
+          case Warning => Some(w)
+          case Error   => Some(w.toError)
+        }
+        case _ => Some(dia)
       }
-      case _ => Some(dia)
-    }
-    for (d <- toReport) {
-      val isSummarized = d match
-        case cw: ConditionalWarning => !cw.enablingOption.value
-        case _ => false
-      // avoid isHidden test for summarized warnings so that message is not forced
-      if isSummarized || !isHidden(d) then
+      for (d <- toReport) {
         withMode(Mode.Printing)(doReport(d))
         d match
           case cw: ConditionalWarning if !cw.enablingOption.value =>
@@ -167,10 +163,28 @@ abstract class Reporter extends interfaces.ReporterResult {
           case e: Error =>
             errors = e :: errors
             _errorCount += 1
-          case dia: Info => // nothing to do here
-          // match error if d is something else
+          case _: Info => // nothing to do here
+        // match error if d is something else
+      }
+
+    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()
+        else
+          sup.addSuspendedMessage(w)
+      case _ => go()
     }
 
+  def report(dia: Diagnostic)(using Context): Unit =
+    val isSummarized = dia match
+      case cw: ConditionalWarning => !cw.enablingOption.value
+      case _ => false
+    // avoid isHidden test for summarized warnings so that message is not forced
+    if isSummarized || !isHidden(dia) then
+      issueIfNotSuppressed(dia)
+
   def incomplete(dia: Diagnostic)(using Context): Unit =
     incompleteHandler(dia, ctx)
 

Diff for: compiler/src/dotty/tools/dotc/reporting/WConf.scala

@@ -3,6 +3,7 @@ package dotc
 package reporting
 
 import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.util.SourcePosition
 
 import java.util.regex.PatternSyntaxException
 import scala.annotation.internal.sharable
@@ -94,3 +95,13 @@ final case class WConf(confs: List[(List[MessageFilter], Action)]):
       if (ms.nonEmpty) Left(ms.flatten)
       else Right(WConf(fs))
     }
+
+case class Suppression(annotPos: SourcePosition, filters: List[MessageFilter], start: Int, end: Int):
+  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))
+  }

Diff for: compiler/src/dotty/tools/dotc/typer/FrontEnd.scala

@@ -80,6 +80,7 @@ class FrontEnd extends Phase {
         typr.println("typed: " + unit.source)
         record("retained untyped trees", unit.untpdTree.treeSize)
         record("retained typed trees after typer", unit.tpdTree.treeSize)
+        ctx.run.suppressions.reportSuspendedMessages(unit)
     catch
       case ex: CompilationUnit.SuspendException =>
   }

Diff for: compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -2104,12 +2104,38 @@ class Typer extends Namer
     lazy val annotCtx = annotContext(mdef, sym)
     // necessary in order to mark the typed ahead annotations as definitely typed:
     for (annot <- mdef.mods.annotations)
-      checkAnnotApplicable(typedAnnotation(annot)(using annotCtx), sym)
+      val annot1 = typedAnnotation(annot)(using annotCtx)
+      checkAnnotApplicable(annot1, sym)
+      if (Annotations.annotClass(annot1) == defn.NowarnAnnot)
+        registerNowarn(annot1, mdef)
   }
 
   def typedAnnotation(annot: untpd.Tree)(using Context): Tree =
     checkAnnotArgs(typed(annot, defn.AnnotationClass.typeRef))
 
+  def registerNowarn(tree: Tree, mdef: untpd.Tree)(using Context): Unit =
+    val annot = Annotations.Annotation(tree)
+    def argPos = annot.argument(0).getOrElse(tree).sourcePos
+    val filters =
+      if annot.arguments.isEmpty then List(MessageFilter.Any)
+      else annot.argumentConstantString(0) match {
+        case None => annot.argument(0) match {
+          case Some(t: Select) if t.name.toString == "$lessinit$greater$default$1" => List(MessageFilter.Any)
+          case _ =>
+            report.error(s"filter needs to be a compile-time constant string", argPos)
+            Nil
+        }
+        case Some(s) =>
+          if s.isEmpty then Nil
+          else
+            val (ms, fs) = s.split('&').map(WConf.parseFilter).toList.partitionMap(identity)
+            if (ms.nonEmpty)
+              report.warning(s"Invalid message filter\n${ms.mkString("\n")}", argPos)
+            fs
+      }
+    val range = mdef.sourcePos
+    ctx.run.suppressions.addSuppression(Suppression(tree.sourcePos, filters, range.start, range.end))
+
   def typedValDef(vdef: untpd.ValDef, sym: Symbol)(using Context): Tree = {
     val ValDef(name, tpt, _) = vdef
     completeAnnotations(vdef, sym)
@@ -2505,6 +2531,8 @@ class Typer extends Namer
 
   def typedAnnotated(tree: untpd.Annotated, pt: Type)(using Context): Tree = {
     val annot1 = typedExpr(tree.annot, defn.AnnotationClass.typeRef)
+    if Annotations.annotClass(annot1) == defn.NowarnAnnot then
+      registerNowarn(annot1, tree)
     val arg1 = typed(tree.arg, pt)
     if (ctx.mode is Mode.Type) {
       if arg1.isType then

Diff for: tests/neg/nowarn.scala

@@ -0,0 +1,22 @@
+import annotation.nowarn
+
+@deprecated def f = 1
+
+def t1 = f // warn
+
+@nowarn("cat=deprecation") def t2 = f
+@nowarn("msg=deprecated") def t3 = f
+@nowarn("msg=fish") def t4 = f // warn
+@nowarn("") def t5 = f
+@nowarn def t6 = f
+
+def t7 = f: @nowarn("cat=deprecation")
+def t8 = f: @nowarn("msg=deprecated")
+def t9 = f: @nowarn("msg=fish") // warn
+def t10 = f: @nowarn("")
+def t11 = f: @nowarn
+
+def t12 = List(List(1): _*) // warn -source:future-migration
+@nowarn("msg=vararg splices") def t13 = List(List(1): _*)
+
+class K { override def blup = 1 } // error