Add suppression if nowarn differs

Author: som-snytt

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

@@ -123,8 +123,13 @@ extends ImplicitRunInfo, ConstraintRunInfo, cc.CaptureRunInfo {
 
     def addSuppression(sup: Suppression): Unit =
       val suppressions = mySuppressions.getOrElseUpdate(sup.annotPos.source, ListBuffer.empty)
-      if sup.start != sup.end && suppressions.forall(x => x.start != sup.start || x.end != sup.end) then
-        suppressions += sup
+      if sup.start != sup.end then
+        suppressions.find(sup.matches(_)) match
+        case Some(other) =>
+          if sup.annotPos != other.annotPos then
+            report.warning("@nowarn annotation is duplicate", sup.annotPos)
+        case none =>
+          suppressions += sup
 
     def reportSuspendedMessages(source: SourceFile)(using Context): Unit = {
       // sort suppressions. they are not added in any particular order because of lazy type completion

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

@@ -10,6 +10,7 @@ import dotty.tools.dotc.interfaces.SourceFile
 import dotty.tools.dotc.reporting.MessageFilter.SourcePattern
 
 import java.util.regex.PatternSyntaxException
+import scala.PartialFunction.cond
 import scala.annotation.internal.sharable
 import scala.util.matching.Regex
 
@@ -136,13 +137,38 @@ object WConf:
       if (parseErrorss.nonEmpty) Left(parseErrorss.flatten)
       else Right(WConf(configs))
 
-class Suppression(val annotPos: SourcePosition, filters: List[MessageFilter], val start: Int, val end: Int, val verbose: Boolean):
+class Suppression(val annotPos: SourcePosition, val filters: List[MessageFilter], val start: Int, val end: Int, val verbose: Boolean):
   private 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))
+  def matches(other: Suppression): Boolean =
+       start == other.start
+    && end == other.end
+    && verbose == other.verbose
+    && filters.lengthCompare(other.filters) == 0
+    && filters.forall(other.hasFilter)
+    && other.filters.forall(hasFilter)
+
+  private def hasFilter(filter: MessageFilter): Boolean =
+    import MessageFilter.*
+    filters.exists:
+      case MessageID(errorId) =>
+        cond(filter):
+          case MessageID(otherId) => errorId == otherId
+      case MessagePattern(pattern) =>
+        cond(filter):
+          case MessagePattern(otherPattern) => pattern.toString == otherPattern.toString
+      case SourcePattern(pattern) =>
+        cond(filter):
+          case SourcePattern(otherPattern) => pattern.toString == otherPattern.toString
+      case Origin(pattern) =>
+        cond(filter):
+          case Origin(otherPattern) => pattern.toString == otherPattern.toString
+      case x => x == filter // Any, Deprecated, Feature, Unchecked, None
 
   override def toString = s"Suppress in ${annotPos.source} $start..$end [${filters.mkString(", ")}]"
+end Suppression

tests/warn/i23651.scala

@@ -0,0 +1,25 @@
+//> using options -deprecation -Wunused:nowarn
+
+import scala.annotation.nowarn
+
+@deprecated
+class A
+
+@deprecated
+class B
+
+@nowarn("msg=class A is deprecated")
+@nowarn("cat=deprecation&msg=class A is deprecated") // warn unused redundant
+@nowarn("cat=deprecation&msg=class B is deprecated")
+trait C1 {
+  def a: A
+  def b: B
+}
+
+@nowarn("cat=deprecation&msg=class B is deprecated")
+@nowarn("cat=deprecation&msg=class B is deprecated") // warn duplicate
+@nowarn("cat=deprecation&msg=class A is deprecated")
+trait C2 {
+  def a: A
+  def b: B
+}