Add -Wunused:params,explicits,implicits,patvars

- Add warnings for unused parmaters (explicit, implicit)
- Add warnings for unused pattern variables (in match case)
- Add tests suits (fatal-warnings)

Author: PaulCoral

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

@@ -163,15 +163,21 @@ private sealed trait WarningSettings:
     name = "-Wunused",
     helpArg = "warning",
     descr = "Enable or disable specific `unused` warnings",
-    choices = List("nowarn", "all", "imports", "locals", "privates"),
+    choices = List("nowarn", "all", "imports", "locals", "privates", "patvars", "explicits", "implicits", "params"),
     default = Nil
   )
   object WunusedHas:
     def allOr(s: String)(using Context) = Wunused.value.pipe(us => us.contains("all") || us.contains(s))
     def nowarn(using Context) = allOr("nowarn")
     def imports(using Context) = allOr("imports")
     def locals(using Context) = allOr("locals")
+    /** -Wunused:explicits OR -Wunused:params */
+    def explicits(using Context) = allOr("explicits") || allOr("params")
+    /** -Wunused:implicits OR -Wunused:params */
+    def implicits(using Context) = allOr("implicits") || allOr("params")
+    def params(using Context) = allOr("params")
     def privates(using Context) = allOr("privates")
+    def patvars(using Context) = allOr("patvars")
 
   val Wconf: Setting[List[String]] = MultiStringSetting(
     "-Wconf",

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

@@ -5,9 +5,9 @@ import dotty.tools.dotc.ast.tpd.TreeTraverser
 import dotty.tools.dotc.ast.untpd
 import dotty.tools.dotc.ast.untpd.ImportSelector
 import dotty.tools.dotc.config.ScalaSettings
-import dotty.tools.dotc.core.Contexts._
-import dotty.tools.dotc.core.Decorators.{i,em}
-import dotty.tools.dotc.core.Flags.{Private, Given}
+import dotty.tools.dotc.core.Contexts.*
+import dotty.tools.dotc.core.Decorators.{em, i}
+import dotty.tools.dotc.core.Flags.{Given, GivenVal, Param, Private}
 import dotty.tools.dotc.core.Phases.Phase
 import dotty.tools.dotc.core.StdNames
 import dotty.tools.dotc.report
@@ -17,6 +17,8 @@ import dotty.tools.dotc.util.Property
 import dotty.tools.dotc.transform.CheckUnused.UnusedData.UnusedResult
 import dotty.tools.dotc.core.Mode
 
+import scala.collection.mutable
+
 
 /**
  * A compiler phase that checks for unused imports or definitions
@@ -36,11 +38,14 @@ class CheckUnused extends Phase:
   override def isRunnable(using Context): Boolean =
     ctx.settings.WunusedHas.imports ||
     ctx.settings.WunusedHas.locals  ||
-    ctx.settings.WunusedHas.privates
+    ctx.settings.WunusedHas.explicits  ||
+    ctx.settings.WunusedHas.implicits  ||
+    ctx.settings.WunusedHas.privates ||
+    ctx.settings.WunusedHas.patvars
 
   override def run(using Context): Unit =
     val tree = ctx.compilationUnit.tpdTree
-    val data = UnusedData(ctx)
+    val data = UnusedData()
     val fresh = ctx.fresh.setProperty(_key, data)
     traverser.traverse(tree)(using fresh)
     reportUnused(data.getUnused)
@@ -56,7 +61,7 @@ class CheckUnused extends Phase:
     import UnusedData.ScopeType
 
     override def traverse(tree: tpd.Tree)(using Context): Unit = tree match
-      case imp@Import(_, sels) => sels.foreach { s =>
+      case imp@Import(_, sels) => sels.foreach { _ =>
           ctx.property(_key).foreach(_.registerImport(imp))
         }
       case ident: Ident =>
@@ -97,20 +102,29 @@ class CheckUnused extends Phase:
       case t:tpd.DefDef =>
         ctx.property(_key).foreach(_.registerDef(t))
         traverseChildren(tree)
+      case t: tpd.Bind =>
+        ctx.property(_key).foreach(_.registerPatVar(t))
+        traverseChildren(tree)
       case _ => traverseChildren(tree)
 
   }
 
-  private def reportUnused(res: UnusedData.UnusedResult)(using Context) =
+  private def reportUnused(res: UnusedData.UnusedResult)(using Context): Unit =
     import CheckUnused.WarnTypes
     res.foreach { s =>
       s match
         case (t, WarnTypes.Imports) =>
           report.warning(s"unused import", t)
         case (t, WarnTypes.LocalDefs) =>
           report.warning(s"unused local definition", t)
+        case (t, WarnTypes.ExplicitParams) =>
+          report.warning(s"unused explicit parameter", t)
+        case (t, WarnTypes.ImplicitParams) =>
+          report.warning(s"unused implicit parameter", t)
         case (t, WarnTypes.PrivateMembers) =>
           report.warning(s"unused private member", t)
+        case (t, WarnTypes.PatVars) =>
+          report.warning(s"unused pattern variable", t)
     }
 
 end CheckUnused
@@ -122,34 +136,45 @@ object CheckUnused:
   enum WarnTypes:
     case Imports
     case LocalDefs
+    case ExplicitParams
+    case ImplicitParams
     case PrivateMembers
+    case PatVars
 
   /**
    * A stateful class gathering the infos on :
    * - imports
    * - definitions
    * - usage
    */
-  private class UnusedData(initctx: Context):
-    import collection.mutable.{Set => MutSet, Map => MutMap, Stack, ListBuffer}
+  private class UnusedData:
+    import collection.mutable.{Set => MutSet, Map => MutMap, Stack => MutStack, ListBuffer}
     import UnusedData.ScopeType
 
     var currScope: ScopeType = ScopeType.Other
 
     /* IMPORTS */
-    private val impInScope = Stack(MutMap[Int, ListBuffer[ImportSelector]]())
+    private val impInScope = MutStack(MutMap[Int, ListBuffer[ImportSelector]]())
     private val unusedImport = MutSet[ImportSelector]()
-    private val usedImports = Stack(MutSet[Int]())
+    private val usedImports = MutStack(MutSet[Int]())
+
+    /* LOCAL DEF OR VAL / Private Def or Val / Pattern variables */
+    private val localDefInScope = MutStack(MutSet[tpd.ValOrDefDef]())
+    private val privateDefInScope = MutStack(MutSet[tpd.ValOrDefDef]())
+    private val explicitParamInScope = MutStack(MutSet[tpd.ValOrDefDef]())
+    private val implicitParamInScope = MutStack(MutSet[tpd.ValOrDefDef]())
+    private val patVarsInScope = MutStack(MutSet[tpd.Bind]())
 
-    /* LOCAL DEF OR VAL / Private Def or Val*/
-    private val localDefInScope = Stack(MutSet[tpd.ValOrDefDef]())
-    private val privateDefInScope = Stack(MutSet[tpd.ValOrDefDef]())
     private val unusedLocalDef = ListBuffer[tpd.ValOrDefDef]()
     private val unusedPrivateDef = ListBuffer[tpd.ValOrDefDef]()
+    private val unusedExplicitParams = ListBuffer[tpd.ValOrDefDef]()
+    private val unusedImplicitParams = ListBuffer[tpd.ValOrDefDef]()
+    private val unusedPatVars = ListBuffer[tpd.Bind]()
+
     private val usedDef = MutSet[Int]()
 
     private def isImportExclusion(sel: ImportSelector): Boolean = sel.renamed match
-      case ident@untpd.Ident(name) => name == StdNames.nme.WILDCARD
+      case untpd.Ident(name) => name == StdNames.nme.WILDCARD
       case _ => false
 
     /** Register the id of a found (used) symbol */
@@ -181,25 +206,39 @@ object CheckUnused:
       }
 
     def registerDef(valOrDef: tpd.ValOrDefDef)(using Context): Unit =
-      if currScope == ScopeType.Local then
+      if valOrDef.symbol.is(Param) then
+        if valOrDef.symbol.is(Given) then
+          implicitParamInScope.top += valOrDef
+        else
+          explicitParamInScope.top += valOrDef
+      else if currScope == ScopeType.Local then
         localDefInScope.top += valOrDef
       else if currScope == ScopeType.Template && valOrDef.symbol.is(Private) then
         privateDefInScope.top += valOrDef
 
+    def registerPatVar(patvar: tpd.Bind)(using Context): Unit =
+      patVarsInScope.top += patvar
+
     /** enter a new scope */
     def pushScope(): Unit =
       // unused imports :
       usedImports.push(MutSet())
       impInScope.push(MutMap())
       // local and private defs :
       localDefInScope.push(MutSet())
+      explicitParamInScope.push(MutSet())
+      implicitParamInScope.push(MutSet())
       privateDefInScope.push(MutSet())
+      patVarsInScope.push(MutSet())
 
     /** leave the current scope */
     def popScope()(using Context): Unit =
       popScopeImport()
       popScopeLocalDef()
+      popScopeExplicitParam()
+      popScopeImplicitParam()
       popScopePrivateDef()
+      popScopePatVars()
 
     def popScopeImport(): Unit =
       val usedImp = MutSet[ImportSelector]()
@@ -211,7 +250,7 @@ object CheckUnused:
             usedImp.addAll(value)
             false
       }
-      if usedImports.size > 0 then
+      if usedImports.nonEmpty then
         usedImports.top.addAll(notDefined)
 
       poppedImp.values.flatten.foreach{ sel =>
@@ -225,12 +264,22 @@ object CheckUnused:
       val unused = localDefInScope.pop().filterInPlace(d => !usedDef(d.symbol.id))
       unusedLocalDef ++= unused
 
+    def popScopeExplicitParam()(using Context): Unit =
+      val unused = explicitParamInScope.pop().filterInPlace(d => !usedDef(d.symbol.id))
+      unusedExplicitParams ++= unused
+
+    def popScopeImplicitParam()(using Context): Unit =
+      val unused = implicitParamInScope.pop().filterInPlace(d => !usedDef(d.symbol.id))
+      unusedImplicitParams ++= unused
+
     def popScopePrivateDef()(using Context): Unit =
-      val unused = privateDefInScope.pop().filterInPlace{d =>
-        !usedDef(d.symbol.id)
-      }
+      val unused = privateDefInScope.pop().filterInPlace(d => !usedDef(d.symbol.id))
       unusedPrivateDef ++= unused
 
+    def popScopePatVars()(using Context): Unit =
+      val unused = patVarsInScope.pop().filterInPlace(d => !usedDef(d.symbol.id))
+      unusedPatVars ++= unused
+
     /**
      * Leave the scope and return a `List` of unused `ImportSelector`s
      *
@@ -245,15 +294,30 @@ object CheckUnused:
           Nil
       val sortedLocalDefs =
         if ctx.settings.WunusedHas.locals then
-          unusedLocalDef.map(d => d.withSpan(d.span.withEnd(d.tpt.startPos.start)) -> WarnTypes.LocalDefs).toList
+          unusedLocalDef.map(d => d.namePos -> WarnTypes.LocalDefs).toList
+        else
+          Nil
+      val sortedExplicitParams =
+        if ctx.settings.WunusedHas.explicits then
+          unusedExplicitParams.map(d => d.namePos -> WarnTypes.ExplicitParams).toList
+        else
+          Nil
+      val sortedImplicitParams =
+        if ctx.settings.WunusedHas.implicits then
+          unusedImplicitParams.map(d => d.namePos -> WarnTypes.ImplicitParams).toList
         else
           Nil
       val sortedPrivateDefs =
         if ctx.settings.WunusedHas.privates then
-          unusedPrivateDef.map(d => d.withSpan(d.span.withEnd(d.tpt.startPos.start)) -> WarnTypes.PrivateMembers).toList
+          unusedPrivateDef.map(d => d.namePos -> WarnTypes.PrivateMembers).toList
+        else
+          Nil
+      val sortedPatVars =
+        if ctx.settings.WunusedHas.patvars then
+          unusedPatVars.map(d => d.namePos -> WarnTypes.PatVars).toList
         else
           Nil
-      List(sortedImp, sortedLocalDefs, sortedPrivateDefs).flatten.sortBy { s =>
+      List(sortedImp, sortedLocalDefs, sortedExplicitParams, sortedImplicitParams, sortedPrivateDefs, sortedPatVars).flatten.sortBy { s =>
         val pos = s._1.sourcePos
         (pos.line, pos.column)
       }
@@ -264,6 +328,7 @@ object CheckUnused:
       enum ScopeType:
         case Local
         case Template
+        case Param
         case Other
 
       type UnusedResult = List[(dotty.tools.dotc.util.SrcPos, WarnTypes)]

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

@@ -0,0 +1,17 @@
+// scalac: -Wunused:patvars
+
+sealed trait Calc
+sealed trait Const extends Calc
+case class Sum(a: Calc, b: Calc) extends Calc
+case class S(pred: Const) extends Const
+case object Z extends Const
+
+val a = Sum(S(S(Z)),Z) match {
+  case Sum(a,Z) => Z // error
+  case Sum(a@S(_),Z) => Z // error
+  case Sum(a@S(_),Z) => a // OK
+  case Sum(a@S(b@S(_)), Z) => a // error
+  case Sum(a@S(b@(S(_))), Z) => Sum(a,b) // OK
+  case Sum(_,_) => Z // OK
+  case _ => Z // OK
+}

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

@@ -0,0 +1,8 @@
+// scalac: -Wunused:explicits
+
+def f1(a: Int) = a // OK
+def f2(a: Int) = 1 // error
+def f3(a: Int)(using Int) = a // OK
+def f4(a: Int)(using Int) = 1 // error
+def f6(a: Int)(using Int) = summon[Int] // error
+def f7(a: Int)(using Int) = summon[Int] + a // OK

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

@@ -0,0 +1,9 @@
+// scalac: -Wunused:implicits
+
+def f1(a: Int) = a // OK
+def f2(a: Int) = 1 // OK
+def f3(a: Int)(using Int) = a // error
+def f4(a: Int)(using Int) = 1 // error
+def f6(a: Int)(using Int) = summon[Int] // OK
+def f7(a: Int)(using Int) = summon[Int] + a // OK
+

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

@@ -0,0 +1,9 @@
+// scalac: -Wunused:params
+
+def f1(a: Int) = a // OK
+def f2(a: Int) = 1 // error
+def f3(a: Int)(using Int) = a // error
+def f4(a: Int)(using Int) = 1 // error // error
+def f6(a: Int)(using Int) = summon[Int] // error
+def f7(a: Int)(using Int) = summon[Int] + a // OK
+