Add support for @annotation.unused

- Does not report defs with @unused
- Update the test suit

Author: PaulCoral

compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -991,6 +991,7 @@ class Definitions {
   @tu lazy val MappedAlternativeAnnot: ClassSymbol = requiredClass("scala.annotation.internal.MappedAlternative")
   @tu lazy val MigrationAnnot: ClassSymbol = requiredClass("scala.annotation.migration")
   @tu lazy val NowarnAnnot: ClassSymbol = requiredClass("scala.annotation.nowarn")
+  @tu lazy val UnusedAnnot: ClassSymbol = requiredClass("scala.annotation.unused")
   @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")

compiler/src/dotty/tools/dotc/transform/CheckUnused.scala

@@ -22,6 +22,8 @@ import dotty.tools.dotc.core.Flags.flagsString
 import dotty.tools.dotc.core.Flags
 import dotty.tools.dotc.core.Names.Name
 import dotty.tools.dotc.transform.MegaPhase.MiniPhase
+import dotty.tools.dotc.core.Annotations
+import dotty.tools.dotc.core.Definitions
 
 
 
@@ -307,20 +309,22 @@ object CheckUnused:
     def registerDef(valOrDef: tpd.ValOrDefDef)(using Context): Unit =
       // register the annotations for usage
       registerUsedAnnotation(valOrDef.symbol)
-      if valOrDef.symbol.is(Param) && !isSyntheticMainParam(valOrDef.symbol) then
-        if valOrDef.symbol.isOneOf(GivenOrImplicit) then
-          implicitParamInScope += valOrDef
-        else
-          explicitParamInScope += valOrDef
-      else if currScopeType.top == ScopeType.Local then
-        localDefInScope += valOrDef
-      else if currScopeType.top == ScopeType.Template && valOrDef.symbol.is(Private, butNot = SelfName) then
-        privateDefInScope += valOrDef
+      if !valOrDef.symbol.isUnusedAnnot then
+        if valOrDef.symbol.is(Param) && !isSyntheticMainParam(valOrDef.symbol) then
+          if valOrDef.symbol.isOneOf(GivenOrImplicit) then
+            implicitParamInScope += valOrDef
+          else
+            explicitParamInScope += valOrDef
+        else if currScopeType.top == ScopeType.Local then
+          localDefInScope += valOrDef
+        else if currScopeType.top == ScopeType.Template && valOrDef.symbol.is(Private, butNot = SelfName) then
+          privateDefInScope += valOrDef
 
     /** Register pattern variable */
     def registerPatVar(patvar: tpd.Bind)(using Context): Unit =
       registerUsedAnnotation(patvar.symbol)
-      patVarsInScope += patvar
+      if !patvar.symbol.isUnusedAnnot then
+        patVarsInScope += patvar
 
     /** enter a new scope */
     def pushScope(newScopeType: ScopeType): Unit =
@@ -478,6 +482,10 @@ object CheckUnused:
           selector.orElse(wildcard) // selector with name or wildcard (or given)
         else
           None
+
+      /** Annotated with @unused */
+      def isUnusedAnnot(using Context): Boolean =
+        sym.annotations.exists(a => a.symbol == ctx.definitions.UnusedAnnot)
   end UnusedData
 
   private object UnusedData:

tests/neg-custom-args/fatal-warnings/i15503i.scala

@@ -29,4 +29,31 @@ class A {
     case x:1 => 0 // error
     case x:2 => x // OK
     case _ => 1 // OK
-}
+}
+
+/* ---- CHECK scala.annotation.unused ---- */
+package foo.test.scala.annotation:
+  import annotation.unused // OK
+
+  def a1(a: Int) = a // OK
+  def a2(a: Int) = 1 // error
+  def a3(@unused a: Int) = 1 //OK
+
+  def b1 =
+    def f = 1 // error
+    1
+
+  def b2 =
+    def f = 1 // OK
+    f
+
+  def b3 =
+    @unused def f = 1 // OK
+    1
+
+  object Foo:
+    private def a = 1 // error
+    private def b = 2 // OK
+    @unused private def c = 3 // OK
+
+    def other = b