Maybe just ignore in inline defs

Author: som-snytt

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

@@ -173,28 +173,20 @@ private sealed trait WarningSettings:
     choices = List(
       ChoiceWithHelp("nowarn", ""),
       ChoiceWithHelp("all", ""),
-      ChoiceWithHelp(
-        name = "imports",
-        description = "Warn if an import selector is not referenced.\n" +
-        "NOTE : overrided by -Wunused:strict-no-implicit-warn"),
+      ChoiceWithHelp("imports", "Warn if an import selector is not referenced."),
       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("patvars","Warn if a variable bound in a pattern is unused"),
+      ChoiceWithHelp("inlined", "Apply -Wunused to inlined expansions"),
       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"
       ),
-      ChoiceWithHelp(
-        name = "unsafe-warn-patvars",
-        description = "(UNSAFE) Warn if a variable bound in a pattern is unused.\n" +
-        "This warning can generate false positive, as warning cannot be\n" +
-        "suppressed yet."
-      )
     ),
     default = Nil
   )
@@ -206,7 +198,6 @@ private sealed trait WarningSettings:
     // Is any choice set for -Wunused?
     def any(using Context): Boolean = Wall.value || Wunused.value.nonEmpty
 
-    // overrided by strict-no-implicit-warn
     def imports(using Context) =
       (allOr("imports") || allOr("linted")) && !(strictNoImplicitWarn)
     def locals(using Context) =
@@ -220,9 +211,8 @@ private sealed trait WarningSettings:
     def params(using Context) = allOr("params")
     def privates(using Context) =
       allOr("privates") || allOr("linted")
-    def patvars(using Context) =
-      allOr("patvars")
-      //isChoiceSet("unsafe-warn-patvars") // not with "all"
+    def patvars(using Context) = allOr("patvars")
+    def inlined(using Context) = isChoiceSet("inlined")
     def linted(using Context) =
       allOr("linted")
     def strictNoImplicitWarn(using Context) =

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

@@ -124,7 +124,8 @@ class CheckUnused private (phaseMode: PhaseMode, suffix: String) extends MiniPha
     refInfos.inlined.push(tree.call.srcPos)
     ctx
   override def transformInlined(tree: Inlined)(using Context): tree.type =
-    val _ = refInfos.inlined.pop()
+    //val _ = refInfos.inlined.pop()
+    val prev = refInfos.inlined.pop()
     if !tree.call.isEmpty && phaseMode.eq(PhaseMode.Aggregate) then
       transformAllDeep(tree.call)
     tree
@@ -176,10 +177,15 @@ class CheckUnused private (phaseMode: PhaseMode, suffix: String) extends MiniPha
     def trivial = tree.symbol.is(Deferred) || isUnconsuming(tree.rhs)
     def nontrivial = tree.symbol.isConstructor || tree.symbol.isAnonymousFunction
     if !nontrivial && trivial then refInfos.skip.addOne(tree.symbol)
-    refInfos.register(tree)
+    if tree.symbol.is(Inline) then
+      refInfos.inliners += 1
+    else
+      refInfos.register(tree)
     ctx
   override def transformDefDef(tree: DefDef)(using Context): tree.type =
     traverseAnnotations(tree.symbol)
+    if tree.symbol.is(Inline) then
+      refInfos.inliners -= 1
     tree
 
   override def transformTypeDef(tree: TypeDef)(using Context): tree.type =
@@ -427,10 +433,11 @@ object CheckUnused:
     val skip = mutable.Set.empty[Symbol]              // methods to skip (don't warn about their params)
     val imps = new IdentityHashMap[Import, Unit]         // imports
     val sels = new IdentityHashMap[ImportSelector, Unit] // matched selectors
-    def register(tree: Tree)(using Context): Unit =
+    def register(tree: Tree)(using Context): Unit = if inlined.isEmpty then
       tree match
       case imp: Import =>
-        if languageImport(imp.expr).isEmpty
+        if inliners == 0
+          && languageImport(imp.expr).isEmpty
           && !imp.isGeneratedByEnum
         then
           imps.put(imp, ())
@@ -449,6 +456,7 @@ object CheckUnused:
 
     var isRepl = false // have we seen a REPL artifact? avoid import warning, for example
     val inlined = Stack.empty[SrcPos] // enclosing call.srcPos of inlined code
+    var inliners = 0 // depth of inline def
   end RefInfos
 
   // Symbols already resolved in the given Context (with name and prefix of lookup)