Warn unused imports

Author: som-snytt

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

@@ -10,7 +10,7 @@ import Scopes._
 import Names.Name
 import Denotations.Denotation
 import typer.{Typer, PrepareInlineable}
-import typer.ImportInfo._
+import typer.ImportInfo.withRootImports
 import Decorators._
 import io.{AbstractFile, PlainFile, VirtualFile}
 import Phases.unfusedPhases

compiler/src/dotty/tools/dotc/ast/untpd.scala

@@ -137,6 +137,8 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
     val rename: TermName = renamed match
       case Ident(rename: TermName) => rename
       case _ => name
+
+    def isMask: Boolean = !isWildcard && (rename == nme.WILDCARD)
   }
 
   case class Number(digits: String, kind: NumberKind)(implicit @constructorOnly src: SourceFile) extends TermTree

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

@@ -3,11 +3,11 @@ package config
 
 import dotty.tools.dotc.config.PathResolver.Defaults
 import dotty.tools.dotc.config.Settings.{Setting, SettingGroup}
-import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.core.Contexts.*
 import dotty.tools.dotc.rewrites.Rewrites
 import dotty.tools.io.{AbstractFile, Directory, JDK9Reflectors, PlainDirectory}
 
-import scala.util.chaining._
+import scala.util.chaining.*
 
 class ScalaSettings extends SettingGroup with AllScalaSettings
 
@@ -146,12 +146,13 @@ private sealed trait WarningSettings:
     name = "-Wunused",
     helpArg = "warning",
     descr = "Enable or disable specific `unused` warnings",
-    choices = List("nowarn", "all"),
+    choices = List("nowarn", "all", "imports"),
     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")
 
   val Wconf: Setting[List[String]] = MultiStringSetting(
     "-Wconf",

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

@@ -6,6 +6,7 @@ import interfaces.CompilerCallback
 import Decorators._
 import Periods._
 import Names._
+import Flags.*
 import Phases._
 import Types._
 import Symbols._
@@ -24,6 +25,7 @@ import io.{AbstractFile, NoAbstractFile, PlainFile, Path}
 import scala.io.Codec
 import collection.mutable
 import printing._
+import config.Printers.{implicits, implicitsDetailed}
 import config.{JavaPlatform, SJSPlatform, Platform, ScalaSettings, ScalaRelease}
 import classfile.ReusableDataReader
 import StdNames.nme
@@ -42,20 +44,27 @@ import dotty.tools.tasty.TastyFormat
 import dotty.tools.dotc.config.{ NoScalaVersion, SpecificScalaVersion, AnyScalaVersion, ScalaBuild }
 import dotty.tools.dotc.core.tasty.TastyVersion
 
-object Contexts {
+import scala.util.chaining.given
 
-  private val (compilerCallbackLoc, store1) = Store.empty.newLocation[CompilerCallback]()
-  private val (sbtCallbackLoc,      store2) = store1.newLocation[AnalysisCallback]()
-  private val (printerFnLoc,        store3) = store2.newLocation[Context => Printer](new RefinedPrinter(_))
-  private val (settingsStateLoc,    store4) = store3.newLocation[SettingsState]()
-  private val (compilationUnitLoc,  store5) = store4.newLocation[CompilationUnit]()
-  private val (runLoc,              store6) = store5.newLocation[Run]()
-  private val (profilerLoc,         store7) = store6.newLocation[Profiler]()
-  private val (notNullInfosLoc,     store8) = store7.newLocation[List[NotNullInfo]]()
-  private val (importInfoLoc,       store9) = store8.newLocation[ImportInfo]()
-  private val (typeAssignerLoc,    store10) = store9.newLocation[TypeAssigner](TypeAssigner)
+object Contexts:
 
-  private val initialStore = store10
+  private var _initialStore        = Store.empty
+  private def newLocation[A]()     = { val (loc, s) = _initialStore.newLocation[A]() ; _initialStore = s ; loc }
+  private def newLocation[A](a: A) = { val (loc, s) = _initialStore.newLocation[A](a) ; _initialStore = s ; loc }
+
+  private val compilerCallbackLoc = newLocation[CompilerCallback]()
+  private val sbtCallbackLoc      = newLocation[AnalysisCallback]()
+  private val printerFnLoc        = newLocation[Context => Printer](new RefinedPrinter(_))
+  private val settingsStateLoc    = newLocation[SettingsState]()
+  private val compilationUnitLoc  = newLocation[CompilationUnit]()
+  private val runLoc              = newLocation[Run]()
+  private val profilerLoc         = newLocation[Profiler]()
+  private val notNullInfosLoc     = newLocation[List[NotNullInfo]]()
+  private val importInfoLoc       = newLocation[ImportInfo]()
+  private val typeAssignerLoc     = newLocation[TypeAssigner](TypeAssigner)
+  private val usagesLoc           = newLocation[Usages](Usages())
+
+  private val initialStore = _initialStore
 
   /** The current context */
   inline def ctx(using ctx: Context): Context = ctx
@@ -241,6 +250,9 @@ object Contexts {
     /** The current type assigner or typer */
     def typeAssigner: TypeAssigner = store(typeAssignerLoc)
 
+    /** Tracker for usages of elements such as import selectors. */
+    def usages: Usages = store(usagesLoc)
+
     /** The new implicit references that are introduced by this scope */
     protected var implicitsCache: ContextualImplicits = null
     def implicits: ContextualImplicits = {
@@ -249,9 +261,7 @@ object Contexts {
           val implicitRefs: List[ImplicitRef] =
             if (isClassDefContext)
               try owner.thisType.implicitMembers
-              catch {
-                case ex: CyclicReference => Nil
-              }
+              catch case ex: CyclicReference => Nil
             else if (isImportContext) importInfo.importedImplicits
             else if (isNonEmptyScopeContext) scope.implicitDecls
             else Nil
@@ -482,8 +492,8 @@ object Contexts {
       else fresh.setOwner(exprOwner)
 
     /** A new context that summarizes an import statement */
-    def importContext(imp: Import[?], sym: Symbol): FreshContext =
-      fresh.setImportInfo(ImportInfo(sym, imp.selectors, imp.expr))
+    def importContext(imp: Import[?], sym: Symbol, enteringSyms: Boolean = false): FreshContext =
+      fresh.setImportInfo(ImportInfo(sym, imp.selectors, imp.expr).tap(ii => if enteringSyms && ctx.settings.WunusedHas.imports then usages += ii))
 
     def scalaRelease: ScalaRelease =
       val releaseName = base.settings.YscalaRelease.value
@@ -957,7 +967,7 @@ object Contexts {
     private[dotc] var stopInlining: Boolean = false
 
     /** A variable that records that some error was reported in a globally committable context.
-     *  The error will not necessarlily be emitted, since it could still be that
+     *  The error will not necessarily be emitted, since it could still be that
      *  the enclosing context will be aborted. The variable is used as a smoke test
      *  to turn off assertions that might be wrong if the program is erroneous. To
      *  just test for `ctx.reporter.errorsReported` is not always enough, since it
@@ -1014,4 +1024,48 @@ object Contexts {
       if (thread == null) thread = Thread.currentThread()
       else assert(thread == Thread.currentThread(), "illegal multithreaded access to ContextBase")
   }
-}
+  end ContextState
+
+  /** Collect information about the run for purposes of additional diagnostics.
+   */
+  class Usages:
+    private val selectors   = mutable.Map.empty[ImportInfo, Set[untpd.ImportSelector]].withDefaultValue(Set.empty)
+    private val importInfos = mutable.Map.empty[CompilationUnit, List[(ImportInfo, Symbol)]].withDefaultValue(Nil)
+
+    // register an import
+    def +=(info: ImportInfo)(using Context): Unit =
+      if ctx.settings.WunusedHas.imports && !ctx.owner.is(Enum) then
+        importInfos(ctx.compilationUnit) ::= ((info, ctx.owner))
+
+    // mark a selector as used
+    def use(info: ImportInfo, selector: untpd.ImportSelector)(using Context): Unit =
+      if ctx.settings.WunusedHas.imports && !info.isRootImport then
+        selectors(info) += selector
+
+    // unused import, owner, which selector
+    def unused(using Context): List[(ImportInfo, Symbol, untpd.ImportSelector)] =
+      var unusages = List.empty[(ImportInfo, Symbol, untpd.ImportSelector)]
+      if ctx.settings.WunusedHas.imports then
+        if ctx.settings.Ydebug.value then
+          println(importInfos.get(ctx.compilationUnit).map(iss => iss.map((ii, s) => s"${ii.show} ($ii)")).getOrElse(Nil).mkString("Registered ImportInfos\n", "\n", ""))
+          println(selectors.toList.flatMap((k,v) => v.toList.map(sel => s"${k.show} -> $sel")).mkString("Used selectors\n", "\n", ""))
+        end if
+        def checkUsed(info: ImportInfo, owner: Symbol): Unit =
+          val used = selectors(info)
+          def cull(toCheck: List[untpd.ImportSelector]): Unit =
+            toCheck match
+              case selector :: rest =>
+                cull(rest) // reverse
+                if !selector.isMask && !used(selector) then
+                  unusages ::= ((info, owner, selector))
+              case _ =>
+          cull(info.selectors)
+        end checkUsed
+        importInfos.remove(ctx.compilationUnit).foreach(_.foreach(checkUsed))
+      unusages
+    end unused
+
+    def clear()(using Context): Unit =
+      importInfos.clear()
+      selectors.clear()
+  end Usages

compiler/src/dotty/tools/dotc/interactive/InteractiveDriver.scala

@@ -146,7 +146,7 @@ class InteractiveDriver(val settings: List[String]) extends Driver {
   def run(uri: URI, sourceCode: String): List[Diagnostic] = run(uri, toSource(uri, sourceCode))
 
   def run(uri: URI, source: SourceFile): List[Diagnostic] = {
-    import typer.ImportInfo._
+    import typer.ImportInfo.withRootImports
 
     val previousCtx = myCtx
     try {

compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala

@@ -8,6 +8,7 @@ import Contexts._
 import Scopes.Scope, Denotations.Denotation, Annotations.Annotation
 import StdNames.nme
 import ast.Trees._
+import ast.untpd
 import typer.Implicits._
 import typer.ImportInfo
 import Variances.varianceSign
@@ -611,12 +612,17 @@ class PlainPrinter(_ctx: Context) extends Printer {
   }
 
   def toText(importInfo: ImportInfo): Text =
+    def selected(sel: untpd.ImportSelector) =
+      if sel.isGiven then "given"
+      else if sel.isWildcard then "*"
+      else if sel.name == sel.rename then sel.name.show
+      else s"${sel.name.show} as ${sel.rename.show}"
     val siteStr = importInfo.site.show
     val exprStr = if siteStr.endsWith(".type") then siteStr.dropRight(5) else siteStr
     val selectorStr = importInfo.selectors match
-      case sel :: Nil if sel.renamed.isEmpty && sel.bound.isEmpty =>
-        if sel.isGiven then "given" else sel.name.show
-      case _ => "{...}"
+      case sel :: Nil if sel.renamed.isEmpty && sel.bound.isEmpty => selected(sel)
+      case sels => sels.map(selected).mkString("{", ", ", "}")
+      //case _ => "{...}"
     s"import $exprStr.$selectorStr"
 
   def toText(c: OrderingConstraint): Text =

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

@@ -70,7 +70,7 @@ object WConf:
         case ErrorId(num) =>
           ErrorMessageID.fromErrorNumber(num.toInt) match
             case Some(errId) => Right(MessageID(errId))
-            case _ => Left(s"unknonw error message number: E$num")
+            case _ => Left(s"unknown error message number: E$num")
         case _ =>
           Left(s"invalid error message id: $conf")
       case "name" =>

compiler/src/dotty/tools/dotc/typer/Implicits.scala

@@ -45,12 +45,17 @@ import scala.annotation.threadUnsafe
 object Implicits:
   import tpd._
 
-  /** An implicit definition `implicitRef` that is visible under a different name, `alias`.
+  /** Pairs an imported `ImplicitRef` with its `ImportInfo` for diagnostic bookkeeping.
+   */
+  class ImportedImplicitRef(val underlyingRef: TermRef, val importInfo: ImportInfo, val selector: Int) extends ImplicitRef:
+    def implicitName(using Context): TermName = underlyingRef.implicitName
+
+  /** An implicit definition `ImplicitRef` that is visible under a different name, `alias`.
    *  Gets generated if an implicit ref is imported via a renaming import.
    */
-  class RenamedImplicitRef(val underlyingRef: TermRef, val alias: TermName) extends ImplicitRef {
-    def implicitName(using Context): TermName = alias
-  }
+  class RenamedImplicitRef(underlyingRef: TermRef, importInfo: ImportInfo, selector: Int, val alias: TermName)
+  extends ImportedImplicitRef(underlyingRef, importInfo, selector):
+    override def implicitName(using Context): TermName = alias
 
   /** Both search candidates and successes are references with a specific nesting level. */
   sealed trait RefAndLevel {
@@ -265,7 +270,9 @@ object Implicits:
           refs.foreach(tryCandidate(extensionOnly = false))
         candidates.toList
     }
+    end filterMatching
   }
+  end ImplicitRefs
 
   /** The implicit references coming from the implicit scope of a type.
    *  @param tp              the type determining the implicit scope
@@ -1123,8 +1130,12 @@ trait Implicits:
               SearchFailure(adapted.withType(new MismatchedImplicit(ref, pt, argument)))
         }
       else
+        cand match
+          case Candidate(k: ImportedImplicitRef, _, _) => ctx.usages.use(k.importInfo, k.importInfo.selectors(k.selector))
+          case _ =>
         SearchSuccess(adapted, ref, cand.level, cand.isExtension)(ctx.typerState, ctx.gadt)
     }
+  end typedImplicit
 
   /** An implicit search; parameters as in `inferImplicit` */
   class ImplicitSearch(protected val pt: Type, protected val argument: Tree, span: Span)(using Context):
@@ -1243,6 +1254,7 @@ trait Implicits:
           else if diff > 0 then alt1
           else SearchFailure(new AmbiguousImplicits(alt1, alt2, pt, argument), span)
         case _: SearchFailure => alt2
+      end disambiguate
 
       /** Try to find a best matching implicit term among all the candidates in `pending`.
        *  @param pending   The list of candidates that remain to be tested
@@ -1312,6 +1324,7 @@ trait Implicits:
             if (rfailures.isEmpty) found
             else found.recoverWith(_ => rfailures.reverse.maxBy(_.tree.treeSize))
         }
+      end rank
 
       def negateIfNot(result: SearchResult) =
         if (isNotGiven)

compiler/src/dotty/tools/dotc/typer/ImportInfo.scala

@@ -8,13 +8,16 @@ import core._
 import printing.{Printer, Showable}
 import util.SimpleIdentityMap
 import Symbols._, Names._, Types._, Contexts._, StdNames._, Flags._
-import Implicits.RenamedImplicitRef
+import Implicits.{ImportedImplicitRef, RenamedImplicitRef}
 import config.SourceVersion
 import StdNames.nme
 import printing.Texts.Text
 import NameKinds.QualifiedName
 import Decorators._
 
+import annotation.*
+import compiletime.uninitialized
+
 object ImportInfo {
 
   case class RootRef(refFn: () => TermRef, isPredef: Boolean = false)
@@ -69,7 +72,7 @@ class ImportInfo(symf: Context ?=> Symbol,
     }
     mySym
   }
-  private var mySym: Symbol = _
+  private var mySym: Symbol = uninitialized
 
   /** The (TermRef) type of the qualifier of the import clause */
   def site(using Context): Type = importSym.info match {
@@ -128,6 +131,11 @@ class ImportInfo(symf: Context ?=> Symbol,
       myWildcardBound = ctx.typer.importBound(selectors, isGiven = false)
     myWildcardBound
 
+  private def givenSelector = selectors.indexWhere(_.isGiven)
+  private def wildSelector = selectors.indexWhere(_.isWildcard)
+  private def selectorOf(name: Name) = selectors.indexWhere(_.name == name)
+  private def selectorOf(original: Name, rename: Name) = selectors.indexWhere(s => s.name == original && s.rename == rename)
+
   /** The implicit references imported by this import clause */
   def importedImplicits(using Context): List[ImplicitRef] =
     val pre = site
@@ -143,10 +151,11 @@ class ImportInfo(symf: Context ?=> Symbol,
               || ctx.mode.is(Mode.FindHiddenImplicits)  // consider both implicits and givens for error reporting
               || ref.symbol.is(Implicit)                // a wildcard `_` import only pulls in implicits
             val bound = if isGivenImport then givenBound else wildcardBound
-            if isEligible && ref.denot.asSingleDenotation.matchesImportBound(bound) then ref :: Nil
+            val selector = if isGivenImport then givenSelector else wildSelector
+            if isEligible && ref.denot.asSingleDenotation.matchesImportBound(bound) then ImportedImplicitRef(ref, this, selector) :: Nil
             else Nil
-          else if renamed == ref.name then ref :: Nil
-          else RenamedImplicitRef(ref, renamed) :: Nil
+          else if renamed == ref.name then ImportedImplicitRef(ref, this, selectorOf(name)) :: Nil
+          else RenamedImplicitRef(ref, this, selectorOf(name, renamed), renamed) :: Nil
       }
     else
       for
@@ -155,8 +164,8 @@ class ImportInfo(symf: Context ?=> Symbol,
       yield
         val original = reverseMapping(renamed)
         val ref = TermRef(pre, original, denot)
-        if renamed == original then ref
-        else RenamedImplicitRef(ref, renamed)
+        if renamed == original then ImportedImplicitRef(ref, this, selectorOf(original))
+        else RenamedImplicitRef(ref, this, selectorOf(original, renamed), renamed)
 
   /** The root import symbol hidden by this symbol, or NoSymbol if no such symbol is hidden.
    *  Note: this computation needs to work even for un-initialized import infos, and
@@ -181,6 +190,7 @@ class ImportInfo(symf: Context ?=> Symbol,
       assert(myUnimported != null)
     myUnimported
 
+  @unused
   private val isLanguageImport: Boolean = untpd.languageImport(qualifier).isDefined
 
   private var myUnimported: Symbol = _
@@ -227,4 +237,9 @@ class ImportInfo(symf: Context ?=> Symbol,
     featureCache(feature)
 
   def toText(printer: Printer): Text = printer.toText(this)
+
+  override def hashCode = qualifier.##
+  override def equals(other: Any) = other match
+    case that: ImportInfo => qualifier == that.qualifier
+    case _                => false
 }

compiler/src/dotty/tools/dotc/typer/Namer.scala

@@ -389,7 +389,7 @@ class Namer { typer: Typer =>
         setDocstring(pkg, stat)
         ctx
       case imp: Import =>
-        ctx.importContext(imp, createSymbol(imp))
+        ctx.importContext(imp, createSymbol(imp), enteringSyms = true)
       case mdef: DefTree =>
         val sym = createSymbol(mdef)
         enterSymbol(sym)