Add -Wunused:strict-no-implicit-warn warning option

- Add the new -Wunused:strict-no-implicit-warn flag
- Add a test suit i15503j

Author: PaulCoral

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

@@ -168,23 +168,33 @@ private sealed trait WarningSettings:
     choices = List(
       ChoiceWithHelp("nowarn", ""),
       ChoiceWithHelp("all",""),
-      ChoiceWithHelp("imports","Warn if an import selector is not referenced"),
+      ChoiceWithHelp(
+        name = "imports",
+        description = "Warn if an import selector is not referenced.\n" +
+        "NOTE : overrided by -Wunused:strict-no-implicit-warn"),
       ChoiceWithHelp("patvars","Warn if a variable bound in a pattern is unused"),
       ChoiceWithHelp("privates","Warn if a private member is unused"),
       ChoiceWithHelp("locals","Warn if a local definition is unused"),
       ChoiceWithHelp("explicits","Warn if an explicit parameter is unused"),
       ChoiceWithHelp("implicits","Warn if an implicit parameter is unused"),
       ChoiceWithHelp("params","Enable -Wunused:explicits,implicits"),
-      ChoiceWithHelp("linted","Enable -Wunused:imports,privates,locals,implicits")
+      ChoiceWithHelp("linted","Enable -Wunused:imports,privates,locals,implicits"),
+      ChoiceWithHelp(
+        name = "strict-no-implicit-warn",
+        description = "Same as -Wunused:import, only for imports of explicit named members.\n" +
+        "NOTE : This overrides -Wunused:imports and NOT set by -Wunused:all"
+      )
     ),
     default = Nil
   )
   object WunusedHas:
+    def isChoiceSet(s: String)(using Context) = Wunused.value.pipe(us => us.contains(s))
     def allOr(s: String)(using Context) = Wunused.value.pipe(us => us.contains("all") || us.contains(s))
     def nowarn(using Context) = allOr("nowarn")
 
+    // overrided by strict-no-implicit-warn
     def imports(using Context) =
-      allOr("imports") || allOr("linted")
+      (allOr("imports") || allOr("linted")) && !(strictNoImplicitWarn)
     def locals(using Context) =
       allOr("locals") || allOr("linted")
     /** -Wunused:explicits OR -Wunused:params */
@@ -196,8 +206,12 @@ private sealed trait WarningSettings:
     def params(using Context) = allOr("params")
     def privates(using Context) =
       allOr("privates") || allOr("linted")
-    def patvars(using Context) = allOr("patvars")
-    def linted(using Context) = allOr("linted")
+    def patvars(using Context) =
+      allOr("patvars")
+    def linted(using Context) =
+      allOr("linted")
+    def strictNoImplicitWarn(using Context) =
+      isChoiceSet("strict-no-implicit-warn")
 
   val Wconf: Setting[List[String]] = MultiStringSetting(
     "-Wconf",

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

@@ -190,12 +190,12 @@ object Settings:
      *
      * NOTE : `equals` and `toString` have special behaviors
      */
-    case class ChoiceWithHelp[T](choice: T, description: String):
+    case class ChoiceWithHelp[T](name: T, description: String):
       override def equals(x: Any): Boolean = x match
-        case s:String => s == choice.toString()
+        case s:String => s == name.toString()
         case _ => false
       override def toString(): String =
-        s"\n\t- $choice${if description.isEmpty() then "" else s"\t: $description"}"
+        s"\n- $name${if description.isEmpty() then "" else s" :\n\t${description.replace("\n","\n\t")}"}"
   end Setting
 
   class SettingGroup {

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

@@ -211,7 +211,9 @@ object CheckUnused:
     def registerImport(imp: tpd.Import)(using Context): Unit =
       if !tpd.languageImport(imp.expr).nonEmpty then
         impInScope.top += imp
-        unusedImport ++= imp.selectors.filter(s => !isImportExclusion(s))
+        unusedImport ++= imp.selectors.filter { s =>
+          !shouldSelectorBeReported(imp, s) && !isImportExclusion(s)
+        }
 
     /** Register (or not) some `val` or `def` according to the context, scope and flags */
     def registerDef(valOrDef: tpd.ValOrDefDef)(using Context): Unit =
@@ -273,7 +275,7 @@ object CheckUnused:
     def getUnused(using Context): UnusedResult =
       popScope()
       val sortedImp =
-        if ctx.settings.WunusedHas.imports then
+        if ctx.settings.WunusedHas.imports || ctx.settings.WunusedHas.strictNoImplicitWarn then
           unusedImport.map(d => d.srcPos -> WarnTypes.Imports).toList
         else
           Nil
@@ -342,6 +344,18 @@ object CheckUnused:
       case untpd.Ident(name) => name == StdNames.nme.WILDCARD
       case _ => false
 
+    /**
+     * If -Wunused:strict-no-implicit-warn import and this import selector could potentially import implicit.
+     * return true
+     */
+    private def shouldSelectorBeReported(imp: tpd.Import, sel: ImportSelector)(using Context): Boolean =
+      if ctx.settings.WunusedHas.strictNoImplicitWarn then
+        sel.isWildcard ||
+        imp.expr.tpe.member(sel.name.toTermName).alternatives.exists(_.symbol.isOneOf(GivenOrImplicit)) ||
+        imp.expr.tpe.member(sel.name.toTypeName).alternatives.exists(_.symbol.isOneOf(GivenOrImplicit))
+      else
+        false
+
     extension (sym: Symbol)
       /** is accessible without import in current context */
       def isAccessibleAsIdent(using Context): Boolean =

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

@@ -0,0 +1,25 @@
+// scalac: -Wunused:strict-no-implicit-warn
+
+package unused.test:
+  package a:
+    given x: Int = 0
+    implicit val y: Int = 1
+    val z: Int = 2
+    def f: Int = 3
+  package b:
+    import a.given // OK
+    import a._ // OK
+    import a.* // OK
+    import a.x // OK
+    import a.y // OK
+    import a.z // error
+    import a.f // error
+  package c:
+    import a.given // OK
+    import a._ // OK
+    import a.* // OK
+    import a.x // OK
+    import a.y // OK
+    import a.z // OK
+    import a.f // OK
+    def g = f + z + y + x