Avoid taking import collection._ as exclusion

Author: som-snytt

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

@@ -139,7 +139,10 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
       case Ident(rename: TermName) => rename
       case _ => name
 
-    def isUnimport = rename == nme.WILDCARD
+    //def isUnimport = rename == nme.WILDCARD // && imported.name != nme.WILDCARD
+    def isUnimport: Boolean = renamed match
+      case Ident(nme.WILDCARD) => true
+      case _ => false
   }
 
   case class Number(digits: String, kind: NumberKind)(implicit @constructorOnly src: SourceFile) extends TermTree

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

@@ -36,11 +36,10 @@ import dotty.tools.dotc.util.Spans.Span
 import scala.math.Ordering
 import scala.util.chaining.given
 
-/**
- * A compiler phase that checks for unused imports or definitions
+/** A compiler phase that checks for unused imports or definitions.
  *
- * Basically, it gathers definition/imports and their usage. If a
- * definition/imports does not have any usage, then it is reported.
+ *  Every construct that introduces a name must have at least one corresponding reference.
+ *  The analysis is restricted to definitions of limited scope, i.e., private and local definitions.
  */
 class CheckUnused private (phaseMode: CheckUnused.PhaseMode, suffix: String, _key: Property.Key[CheckUnused.UnusedData]) extends MiniPhase:
   import CheckUnused.*
@@ -726,7 +725,7 @@ object CheckUnused:
         sym.annotations.exists(a => a.symbol == ctx.definitions.UnusedAnnot)
 
       private def shouldNotReportParamOwner(using Context): Boolean =
-        if sym.exists then
+        sym.exists && {
           val owner = sym.owner
           trivialDefs(owner) || // is a trivial def
           owner.isPrimaryConstructor ||
@@ -735,18 +734,17 @@ object CheckUnused:
           ) ||
           owner.isAllOf(Synthetic | PrivateLocal) ||
           owner.is(Accessor) ||
-          owner.isOverriden
-        else
-          false
+          owner.isOverridden
+        }
 
       private def usedDefContains(using Context): Boolean =
         sym.everySymbol.exists(usedDef.apply)
 
       private def everySymbol(using Context): List[Symbol] =
         List(sym, sym.companionClass, sym.companionModule, sym.moduleClass).filter(_.exists)
 
-      /** A function is overriden. Either has `override flags` or parent has a matching member (type and name) */
-      private def isOverriden(using Context): Boolean =
+      /** A function is overridden. Either has `override flags` or parent has a matching member (type and name) */
+      private def isOverridden(using Context): Boolean =
         sym.is(Flags.Override) || (sym.exists && sym.owner.thisType.parents.exists(p => sym.matchingMember(p).exists))
 
     end extension