From 0f85c64e64cb74ad7a89c7639923c424fc7d538e Mon Sep 17 00:00:00 2001
From: Paul Coral <paul.coral@epfl.ch>
Date: Wed, 15 Feb 2023 16:44:55 +0100
Subject: [PATCH 01/15] Fix #16822

- Ignore synthetic local private
- Update test suit
---
 .../tools/dotc/transform/CheckUnused.scala    | 19 +++++++--------
 .../fatal-warnings/i15503i.scala              | 23 ++++++++++++++-----
 2 files changed, 27 insertions(+), 15 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
index 59878757c39b..6c47c12ac07c 100644
--- a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
@@ -81,7 +81,7 @@ class CheckUnused extends MiniPhase:
     ctx
 
   override def prepareForIdent(tree: tpd.Ident)(using Context): Context =
-    if tree.symbol.exists then 
+    if tree.symbol.exists then
       _key.unusedDataApply(_.registerUsed(tree.symbol, Some(tree.name)))
     else if tree.hasType then
       _key.unusedDataApply(_.registerUsed(tree.tpe.classSymbol, Some(tree.name)))
@@ -103,7 +103,7 @@ class CheckUnused extends MiniPhase:
   override def prepareForValDef(tree: tpd.ValDef)(using Context): Context =
     _key.unusedDataApply{ud =>
       // do not register the ValDef generated for `object`
-      if !tree.symbol.is(Module) then 
+      if !tree.symbol.is(Module) then
         ud.registerDef(tree)
       ud.addIgnoredUsage(tree.symbol)
     }
@@ -335,7 +335,7 @@ object CheckUnused:
      * The optional name will be used to target the right import
      * as the same element can be imported with different renaming
      */
-    def registerUsed(sym: Symbol, name: Option[Name])(using Context): Unit =      
+    def registerUsed(sym: Symbol, name: Option[Name])(using Context): Unit =
       if !isConstructorOfSynth(sym) && !doNotRegister(sym) then
         if sym.isConstructor && sym.exists then
           registerUsed(sym.owner, None) // constructor are "implicitly" imported with the class
@@ -371,7 +371,7 @@ object CheckUnused:
             implicitParamInScope += memDef
           else
             explicitParamInScope += memDef
-        else if currScopeType.top == ScopeType.Local then 
+        else if currScopeType.top == ScopeType.Local then
           localDefInScope += memDef
         else if memDef.shouldReportPrivateDef then
           privateDefInScope += memDef
@@ -578,10 +578,10 @@ object CheckUnused:
         else
           false
 
-      private def usedDefContains(using Context): Boolean = 
+      private def usedDefContains(using Context): Boolean =
         sym.everySymbol.exists(usedDef.apply)
 
-      private def everySymbol(using Context): List[Symbol] = 
+      private def everySymbol(using Context): List[Symbol] =
         List(sym, sym.companionClass, sym.companionModule, sym.moduleClass).filter(_.exists)
 
     end extension
@@ -614,10 +614,11 @@ object CheckUnused:
       private def isValidParam(using Context): Boolean =
         val sym = memDef.symbol
         (sym.is(Param) || sym.isAllOf(PrivateParamAccessor | Local, butNot = CaseAccessor)) &&
-        !isSyntheticMainParam(sym)  &&
-        !sym.shouldNotReportParamOwner
+        !isSyntheticMainParam(sym) &&
+        !sym.shouldNotReportParamOwner &&
+        (!sym.exists || !sym.owner.isAllOf(Synthetic | PrivateLocal))
 
-      private def shouldReportPrivateDef(using Context): Boolean = 
+      private def shouldReportPrivateDef(using Context): Boolean =
         currScopeType.top == ScopeType.Template && !memDef.symbol.isConstructor && memDef.symbol.is(Private, butNot = SelfName | Synthetic | CaseAccessor)
 
     extension (imp: tpd.Import)
diff --git a/tests/neg-custom-args/fatal-warnings/i15503i.scala b/tests/neg-custom-args/fatal-warnings/i15503i.scala
index 33e04f34daa8..7eae207d952d 100644
--- a/tests/neg-custom-args/fatal-warnings/i15503i.scala
+++ b/tests/neg-custom-args/fatal-warnings/i15503i.scala
@@ -78,13 +78,13 @@ package foo.test.companionprivate:
 package foo.test.i16678:
   def foo(func: Int => String, value: Int): String = func(value) // OK
 
-  def run = 
+  def run =
     println(foo(number => number.toString, value = 5)) // OK
     println(foo(number => "<number>", value = 5)) // error
     println(foo(func = number => "<number>", value = 5)) // error
     println(foo(func = number => number.toString, value = 5)) // OK
     println(foo(func = _.toString, value = 5)) // OK
-    
+
 package foo.test.possibleclasses:
   case class AllCaseClass(
     k: Int, // OK
@@ -93,7 +93,7 @@ package foo.test.possibleclasses:
     s: Int, // error /* But not these */
     val t: Int, // OK
     private val z: Int // error
-  )       
+  )
 
   case class AllCaseUsed(
     k: Int, // OK
@@ -113,7 +113,7 @@ package foo.test.possibleclasses:
     s: Int, // error
     val t: Int, // OK
     private val z: Int // error
-  )      
+  )
 
   class AllUsed(
     k: Int, // OK
@@ -124,10 +124,21 @@ package foo.test.possibleclasses:
     private val z: Int // OK
   ) {
     def a = k + y + s + t + z
-  } 
+  }
 
 package foo.test.from.i16675:
   case class PositiveNumber private (i: Int) // OK
   object PositiveNumber:
-    def make(i: Int): Option[PositiveNumber] = //OK 
+    def make(i: Int): Option[PositiveNumber] = //OK
       Option.when(i >= 0)(PositiveNumber(i)) // OK
+
+package foo.test.i16822:
+  enum ExampleEnum {
+    case Build(context: String) // OK
+    case List // OK
+  }
+
+  def demo = {
+    val x = ExampleEnum.List // OK
+    println(x) // OK
+  }

From 609bc59900169c32708347aee33136bf26f6668f Mon Sep 17 00:00:00 2001
From: Paul Coral <paul.coral@epfl.ch>
Date: Sat, 18 Feb 2023 16:41:59 +0100
Subject: [PATCH 02/15] Traverse annotations instead of just registering

- Traverse the tree of annotations
- Update test suits
---
 .../tools/dotc/transform/CheckUnused.scala     | 18 +++++++++---------
 .../fatal-warnings/i15503i.scala               |  9 +++++++++
 2 files changed, 18 insertions(+), 9 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
index 6c47c12ac07c..f66412e16d36 100644
--- a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
@@ -28,6 +28,7 @@ import dotty.tools.dotc.core.Types.ConstantType
 import dotty.tools.dotc.core.NameKinds.WildcardParamName
 import dotty.tools.dotc.core.Types.TermRef
 import dotty.tools.dotc.core.Types.NameFilter
+import dotty.tools.dotc.core.Symbols.Symbol
 
 
 
@@ -103,6 +104,7 @@ class CheckUnused extends MiniPhase:
   override def prepareForValDef(tree: tpd.ValDef)(using Context): Context =
     _key.unusedDataApply{ud =>
       // do not register the ValDef generated for `object`
+      traverseAnnotations(tree.symbol)
       if !tree.symbol.is(Module) then
         ud.registerDef(tree)
       ud.addIgnoredUsage(tree.symbol)
@@ -112,6 +114,7 @@ class CheckUnused extends MiniPhase:
     _key.unusedDataApply{ ud =>
       import ud.registerTrivial
       tree.registerTrivial
+      traverseAnnotations(tree.symbol)
       ud.registerDef(tree)
       ud.addIgnoredUsage(tree.symbol)
     }
@@ -119,11 +122,13 @@ class CheckUnused extends MiniPhase:
   override def prepareForTypeDef(tree: tpd.TypeDef)(using Context): Context =
     _key.unusedDataApply{ ud =>
       if !tree.symbol.is(Param) then // Ignore type parameter (as Scala 2)
+        traverseAnnotations(tree.symbol)
         ud.registerDef(tree)
         ud.addIgnoredUsage(tree.symbol)
     }
 
   override def prepareForBind(tree: tpd.Bind)(using Context): Context =
+    traverseAnnotations(tree.symbol)
     _key.unusedDataApply(_.registerPatVar(tree))
 
   override def prepareForTypeTree(tree: tpd.TypeTree)(using Context): Context =
@@ -232,6 +237,10 @@ class CheckUnused extends MiniPhase:
       case AnnotatedType(_, annot) => dt(_.registerUsed(annot.symbol, None))
       case _ => traverseChildren(tp)
 
+  /** This traverse the annotations of the symbol */
+  private def traverseAnnotations(sym: Symbol)(using Context): Unit =
+    sym.denot.annotations.foreach(annot => traverser.traverse(annot.tree))
+
   /** Do the actual reporting given the result of the anaylsis */
   private def reportUnused(res: UnusedData.UnusedResult)(using Context): Unit =
     import CheckUnused.WarnTypes
@@ -274,7 +283,6 @@ object CheckUnused:
   private class UnusedData:
     import dotty.tools.dotc.transform.CheckUnused.UnusedData.UnusedResult
     import collection.mutable.{Set => MutSet, Map => MutMap, Stack => MutStack}
-    import dotty.tools.dotc.core.Symbols.Symbol
     import UnusedData.ScopeType
 
     /** The current scope during the tree traversal */
@@ -324,11 +332,6 @@ object CheckUnused:
       execInNewScope
       popScope()
 
-    /** Register all annotations of this symbol's denotation */
-    def registerUsedAnnotation(sym: Symbol)(using Context): Unit =
-      val annotSym = sym.denot.annotations.map(_.symbol)
-      annotSym.foreach(s => registerUsed(s, None))
-
     /**
      * Register a found (used) symbol along with its name
      *
@@ -363,8 +366,6 @@ object CheckUnused:
 
     /** Register (or not) some `val` or `def` according to the context, scope and flags */
     def registerDef(memDef: tpd.MemberDef)(using Context): Unit =
-      // register the annotations for usage
-      registerUsedAnnotation(memDef.symbol)
       if memDef.isValidMemberDef then
         if memDef.isValidParam then
           if memDef.symbol.isOneOf(GivenOrImplicit) then
@@ -378,7 +379,6 @@ object CheckUnused:
 
     /** Register pattern variable */
     def registerPatVar(patvar: tpd.Bind)(using Context): Unit =
-      registerUsedAnnotation(patvar.symbol)
       if !patvar.symbol.isUnusedAnnot then
         patVarsInScope += patvar
 
diff --git a/tests/neg-custom-args/fatal-warnings/i15503i.scala b/tests/neg-custom-args/fatal-warnings/i15503i.scala
index 7eae207d952d..ccf9344319d2 100644
--- a/tests/neg-custom-args/fatal-warnings/i15503i.scala
+++ b/tests/neg-custom-args/fatal-warnings/i15503i.scala
@@ -142,3 +142,12 @@ package foo.test.i16822:
     val x = ExampleEnum.List // OK
     println(x) // OK
   }
+
+package foo.test.i16877:
+  import scala.collection.immutable.HashMap // OK
+  import scala.annotation.StaticAnnotation // OK
+
+  class ExampleAnnotation(val a: Object) extends StaticAnnotation // OK
+
+  @ExampleAnnotation(new HashMap()) // OK
+  class Test //OK

From 57bf2f4f4029ded6339c3ade52fe3de479dfa841 Mon Sep 17 00:00:00 2001
From: Szymon Rodziewicz <szymonrodant@gmail.com>
Date: Mon, 27 Feb 2023 16:03:10 +0100
Subject: [PATCH 03/15] WUnused: Fix unused warnining in synthetic symbols

---
 compiler/src/dotty/tools/dotc/transform/CheckUnused.scala | 8 ++++++--
 tests/neg-custom-args/fatal-warnings/i16925.scala         | 8 ++++++++
 tests/neg-custom-args/fatal-warnings/i16926.scala         | 7 +++++++
 3 files changed, 21 insertions(+), 2 deletions(-)
 create mode 100644 tests/neg-custom-args/fatal-warnings/i16925.scala
 create mode 100644 tests/neg-custom-args/fatal-warnings/i16926.scala

diff --git a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
index f66412e16d36..1a39e162d5ed 100644
--- a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
@@ -7,13 +7,13 @@ 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.{em, i}
-import dotty.tools.dotc.core.Flags._
+import dotty.tools.dotc.core.Flags.*
 import dotty.tools.dotc.core.Phases.Phase
 import dotty.tools.dotc.core.StdNames
 import dotty.tools.dotc.report
 import dotty.tools.dotc.reporting.Message
 import dotty.tools.dotc.typer.ImportInfo
-import dotty.tools.dotc.util.Property
+import dotty.tools.dotc.util.{Property, SourcePosition, SrcPos}
 import dotty.tools.dotc.core.Mode
 import dotty.tools.dotc.core.Types.TypeTraverser
 import dotty.tools.dotc.core.Types.Type
@@ -297,6 +297,7 @@ object CheckUnused:
      * See the `isAccessibleAsIdent` extension method below in the file
      */
     private val usedInScope = MutStack(MutSet[(Symbol,Boolean, Option[Name])]())
+    private val usedInPosition = MutSet[(SrcPos, Name)]()
     /* unused import collected during traversal */
     private val unusedImport = MutSet[ImportSelector]()
 
@@ -346,6 +347,7 @@ object CheckUnused:
           usedInScope.top += ((sym, sym.isAccessibleAsIdent, name))
           usedInScope.top += ((sym.companionModule, sym.isAccessibleAsIdent, name))
           usedInScope.top += ((sym.companionClass, sym.isAccessibleAsIdent, name))
+          name.map(n => usedInPosition += ((sym.sourcePos, n)))
 
     /** Register a symbol that should be ignored */
     def addIgnoredUsage(sym: Symbol)(using Context): Unit =
@@ -450,6 +452,7 @@ object CheckUnused:
         if ctx.settings.WunusedHas.locals then
           localDefInScope
             .filterNot(d => d.symbol.usedDefContains)
+            .filterNot(d => usedInPosition.exists { case (pos, name) => d.span.contains(pos.span) && name == d.symbol.name})
             .map(d => d.namePos -> WarnTypes.LocalDefs).toList
         else
           Nil
@@ -478,6 +481,7 @@ object CheckUnused:
         if ctx.settings.WunusedHas.patvars then
           patVarsInScope
             .filterNot(d => d.symbol.usedDefContains)
+            .filterNot(d => usedInPosition.exists { case (pos, name) => d.span.contains(pos.span) && name == d.symbol.name})
             .map(d => d.namePos -> WarnTypes.PatVars).toList
         else
           Nil
diff --git a/tests/neg-custom-args/fatal-warnings/i16925.scala b/tests/neg-custom-args/fatal-warnings/i16925.scala
new file mode 100644
index 000000000000..5cc94f53cdd4
--- /dev/null
+++ b/tests/neg-custom-args/fatal-warnings/i16925.scala
@@ -0,0 +1,8 @@
+// scalac: -Wunused:all
+
+def hello =
+  for {
+    i <- 1 to 2 if true
+    _ = println(i) // OK
+  } yield ()
+
diff --git a/tests/neg-custom-args/fatal-warnings/i16926.scala b/tests/neg-custom-args/fatal-warnings/i16926.scala
new file mode 100644
index 000000000000..23f167f4ce30
--- /dev/null
+++ b/tests/neg-custom-args/fatal-warnings/i16926.scala
@@ -0,0 +1,7 @@
+// scalac: -Wunused:all
+
+def hello(): Unit =
+  for {
+    i <- (0 to 10).toList
+    (a, b) = "hello" -> "world" // OK
+  } yield println(s"$a $b")

From b6cb7b9928e0afb0bf95b777f400ffd62174da4d Mon Sep 17 00:00:00 2001
From: Szymon Rodziewicz <szymonrodant@gmail.com>
Date: Tue, 28 Feb 2023 12:55:33 +0100
Subject: [PATCH 04/15] Move tests

---
 tests/neg-custom-args/fatal-warnings/i15503i.scala | 14 ++++++++++++++
 tests/neg-custom-args/fatal-warnings/i16925.scala  |  8 --------
 tests/neg-custom-args/fatal-warnings/i16926.scala  |  7 -------
 3 files changed, 14 insertions(+), 15 deletions(-)
 delete mode 100644 tests/neg-custom-args/fatal-warnings/i16925.scala
 delete mode 100644 tests/neg-custom-args/fatal-warnings/i16926.scala

diff --git a/tests/neg-custom-args/fatal-warnings/i15503i.scala b/tests/neg-custom-args/fatal-warnings/i15503i.scala
index ccf9344319d2..e0675a060fdb 100644
--- a/tests/neg-custom-args/fatal-warnings/i15503i.scala
+++ b/tests/neg-custom-args/fatal-warnings/i15503i.scala
@@ -151,3 +151,17 @@ package foo.test.i16877:
 
   @ExampleAnnotation(new HashMap()) // OK
   class Test //OK
+
+package foo.test.i16926:
+  def hello(): Unit =
+    for {
+      i <- (0 to 10).toList
+      (a, b) = "hello" -> "world" // OK
+    } yield println(s"$a $b")
+
+package foo.test.i16925:
+  def hello =
+    for {
+      i <- 1 to 2 if true
+      _ = println(i) // OK
+    } yield ()
diff --git a/tests/neg-custom-args/fatal-warnings/i16925.scala b/tests/neg-custom-args/fatal-warnings/i16925.scala
deleted file mode 100644
index 5cc94f53cdd4..000000000000
--- a/tests/neg-custom-args/fatal-warnings/i16925.scala
+++ /dev/null
@@ -1,8 +0,0 @@
-// scalac: -Wunused:all
-
-def hello =
-  for {
-    i <- 1 to 2 if true
-    _ = println(i) // OK
-  } yield ()
-
diff --git a/tests/neg-custom-args/fatal-warnings/i16926.scala b/tests/neg-custom-args/fatal-warnings/i16926.scala
deleted file mode 100644
index 23f167f4ce30..000000000000
--- a/tests/neg-custom-args/fatal-warnings/i16926.scala
+++ /dev/null
@@ -1,7 +0,0 @@
-// scalac: -Wunused:all
-
-def hello(): Unit =
-  for {
-    i <- (0 to 10).toList
-    (a, b) = "hello" -> "world" // OK
-  } yield println(s"$a $b")

From be906dd72e369a8ab3f10b95ed4b343f805421ed Mon Sep 17 00:00:00 2001
From: Szymon Rodziewicz <szymonrodant@gmail.com>
Date: Tue, 28 Feb 2023 17:54:21 +0100
Subject: [PATCH 05/15] Remove unused import

---
 compiler/src/dotty/tools/dotc/transform/CheckUnused.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
index 1a39e162d5ed..a5c4a7722106 100644
--- a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
@@ -13,7 +13,7 @@ import dotty.tools.dotc.core.StdNames
 import dotty.tools.dotc.report
 import dotty.tools.dotc.reporting.Message
 import dotty.tools.dotc.typer.ImportInfo
-import dotty.tools.dotc.util.{Property, SourcePosition, SrcPos}
+import dotty.tools.dotc.util.{Property, SrcPos}
 import dotty.tools.dotc.core.Mode
 import dotty.tools.dotc.core.Types.TypeTraverser
 import dotty.tools.dotc.core.Types.Type

From 452fac6016ab5b3833c3c48824dfd2e20d960fbe Mon Sep 17 00:00:00 2001
From: Kacper Korban <kacper.f.korban@gmail.com>
Date: Thu, 16 Feb 2023 15:53:07 +0100
Subject: [PATCH 06/15] Register usage of symbols in non-inferred type trees in
 CheckUnused

fixes lampepfl#16930
---
 .../tools/dotc/transform/CheckUnused.scala    | 57 ++++++++++---------
 .../fatal-warnings/i16930.scala               | 22 +++++++
 2 files changed, 53 insertions(+), 26 deletions(-)
 create mode 100644 tests/neg-custom-args/fatal-warnings/i16930.scala

diff --git a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
index a5c4a7722106..48f94cdc5211 100644
--- a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
@@ -47,12 +47,11 @@ class CheckUnused extends MiniPhase:
    */
   private val _key = Property.Key[UnusedData]
 
-  extension (k: Property.Key[UnusedData])
-    private def unusedDataApply[U](f: UnusedData => U)(using Context): Context =
-      ctx.property(_key).foreach(f)
-      ctx
-    private def getUnusedData(using Context): Option[UnusedData] =
-      ctx.property(_key)
+  private def unusedDataApply[U](f: UnusedData => U)(using Context): Context =
+    ctx.property(_key).foreach(f)
+    ctx
+  private def getUnusedData(using Context): Option[UnusedData] =
+    ctx.property(_key)
 
   override def phaseName: String = CheckUnused.phaseName
 
@@ -72,7 +71,7 @@ class CheckUnused extends MiniPhase:
   // ========== END + REPORTING ==========
 
   override def transformUnit(tree: tpd.Tree)(using Context): tpd.Tree =
-    _key.unusedDataApply(ud => reportUnused(ud.getUnused))
+    unusedDataApply(ud => reportUnused(ud.getUnused))
     tree
 
   // ========== MiniPhase Prepare ==========
@@ -83,14 +82,14 @@ class CheckUnused extends MiniPhase:
 
   override def prepareForIdent(tree: tpd.Ident)(using Context): Context =
     if tree.symbol.exists then
-      _key.unusedDataApply(_.registerUsed(tree.symbol, Some(tree.name)))
+      unusedDataApply(_.registerUsed(tree.symbol, Some(tree.name)))
     else if tree.hasType then
-      _key.unusedDataApply(_.registerUsed(tree.tpe.classSymbol, Some(tree.name)))
+      unusedDataApply(_.registerUsed(tree.tpe.classSymbol, Some(tree.name)))
     else
       ctx
 
   override def prepareForSelect(tree: tpd.Select)(using Context): Context =
-    _key.unusedDataApply(_.registerUsed(tree.symbol, Some(tree.name)))
+    unusedDataApply(_.registerUsed(tree.symbol, Some(tree.name)))
 
   override def prepareForBlock(tree: tpd.Block)(using Context): Context =
     pushInBlockTemplatePackageDef(tree)
@@ -102,7 +101,7 @@ class CheckUnused extends MiniPhase:
     pushInBlockTemplatePackageDef(tree)
 
   override def prepareForValDef(tree: tpd.ValDef)(using Context): Context =
-    _key.unusedDataApply{ud =>
+    unusedDataApply{ud =>
       // do not register the ValDef generated for `object`
       traverseAnnotations(tree.symbol)
       if !tree.symbol.is(Module) then
@@ -111,7 +110,7 @@ class CheckUnused extends MiniPhase:
     }
 
   override def prepareForDefDef(tree: tpd.DefDef)(using Context): Context =
-    _key.unusedDataApply{ ud =>
+    unusedDataApply{ ud =>
       import ud.registerTrivial
       tree.registerTrivial
       traverseAnnotations(tree.symbol)
@@ -120,7 +119,7 @@ class CheckUnused extends MiniPhase:
     }
 
   override def prepareForTypeDef(tree: tpd.TypeDef)(using Context): Context =
-    _key.unusedDataApply{ ud =>
+    unusedDataApply{ ud =>
       if !tree.symbol.is(Param) then // Ignore type parameter (as Scala 2)
         traverseAnnotations(tree.symbol)
         ud.registerDef(tree)
@@ -129,10 +128,10 @@ class CheckUnused extends MiniPhase:
 
   override def prepareForBind(tree: tpd.Bind)(using Context): Context =
     traverseAnnotations(tree.symbol)
-    _key.unusedDataApply(_.registerPatVar(tree))
+    unusedDataApply(_.registerPatVar(tree))
 
   override def prepareForTypeTree(tree: tpd.TypeTree)(using Context): Context =
-    typeTraverser(_key.unusedDataApply).traverse(tree.tpe)
+    if !tree.isInstanceOf[tpd.InferredTypeTree] then typeTraverser(unusedDataApply).traverse(tree.tpe)
     ctx
 
   // ========== MiniPhase Transform ==========
@@ -150,27 +149,27 @@ class CheckUnused extends MiniPhase:
     tree
 
   override def transformValDef(tree: tpd.ValDef)(using Context): tpd.Tree =
-    _key.unusedDataApply(_.removeIgnoredUsage(tree.symbol))
+    unusedDataApply(_.removeIgnoredUsage(tree.symbol))
     tree
 
   override def transformDefDef(tree: tpd.DefDef)(using Context): tpd.Tree =
-    _key.unusedDataApply(_.removeIgnoredUsage(tree.symbol))
+    unusedDataApply(_.removeIgnoredUsage(tree.symbol))
     tree
 
   override def transformTypeDef(tree: tpd.TypeDef)(using Context): tpd.Tree =
-    _key.unusedDataApply(_.removeIgnoredUsage(tree.symbol))
+    unusedDataApply(_.removeIgnoredUsage(tree.symbol))
     tree
 
   // ---------- MiniPhase HELPERS -----------
 
   private def pushInBlockTemplatePackageDef(tree: tpd.Block | tpd.Template | tpd.PackageDef)(using Context): Context =
-    _key.unusedDataApply { ud =>
+    unusedDataApply { ud =>
       ud.pushScope(UnusedData.ScopeType.fromTree(tree))
     }
     ctx
 
   private def popOutBlockTemplatePackageDef()(using Context): Context =
-    _key.unusedDataApply { ud =>
+    unusedDataApply { ud =>
       ud.popScope()
     }
     ctx
@@ -193,7 +192,7 @@ class CheckUnused extends MiniPhase:
       val newCtx = if tree.symbol.exists then ctx.withOwner(tree.symbol) else ctx
       tree match
         case imp:tpd.Import =>
-          _key.unusedDataApply(_.registerImport(imp))
+          unusedDataApply(_.registerImport(imp))
           traverseChildren(tree)(using newCtx)
         case ident: Ident =>
           prepareForIdent(ident)
@@ -203,7 +202,7 @@ class CheckUnused extends MiniPhase:
           traverseChildren(tree)(using newCtx)
         case _: (tpd.Block | tpd.Template | tpd.PackageDef) =>
           //! DIFFERS FROM MINIPHASE
-          _key.unusedDataApply { ud =>
+          unusedDataApply { ud =>
             ud.inNewScope(ScopeType.fromTree(tree))(traverseChildren(tree)(using newCtx))
           }
         case t:tpd.ValDef =>
@@ -221,9 +220,10 @@ class CheckUnused extends MiniPhase:
         case t: tpd.Bind =>
           prepareForBind(t)
           traverseChildren(tree)(using newCtx)
+        case _: tpd.InferredTypeTree =>
         case t@tpd.TypeTree() =>
           //! DIFFERS FROM MINIPHASE
-          typeTraverser(_key.unusedDataApply).traverse(t.tpe)
+          typeTraverser(unusedDataApply).traverse(t.tpe)
           traverseChildren(tree)(using newCtx)
         case _ =>
           //! DIFFERS FROM MINIPHASE
@@ -233,9 +233,14 @@ class CheckUnused extends MiniPhase:
 
   /** This is a type traverser which catch some special Types not traversed by the term traverser above */
   private def typeTraverser(dt: (UnusedData => Any) => Unit)(using Context) = new TypeTraverser:
-    override def traverse(tp: Type): Unit = tp match
-      case AnnotatedType(_, annot) => dt(_.registerUsed(annot.symbol, None))
-      case _ => traverseChildren(tp)
+    override def traverse(tp: Type): Unit =
+      if tp.typeSymbol.exists then dt(_.registerUsed(tp.typeSymbol, Some(tp.typeSymbol.name)))
+      tp match
+        case AnnotatedType(_, annot) =>
+          dt(_.registerUsed(annot.symbol, None))
+          traverseChildren(tp)
+        case _ =>
+          traverseChildren(tp)
 
   /** This traverse the annotations of the symbol */
   private def traverseAnnotations(sym: Symbol)(using Context): Unit =
diff --git a/tests/neg-custom-args/fatal-warnings/i16930.scala b/tests/neg-custom-args/fatal-warnings/i16930.scala
new file mode 100644
index 000000000000..1f6c5bf1a09f
--- /dev/null
+++ b/tests/neg-custom-args/fatal-warnings/i16930.scala
@@ -0,0 +1,22 @@
+// scalac: -Wunused:imports
+
+trait Outer:
+  trait Used
+  trait Unused
+
+object Test {
+  val outer: Outer = ???
+  import outer.{Used, Unused} // error
+  def foo(x: Any): Used = x.asInstanceOf[Used]
+}
+
+trait Outer1:
+  trait UnusedToo1
+  trait Unused1
+  def unusedToo1: UnusedToo1
+
+object Test1 {
+  val outer1: Outer1 = ???
+  import outer1.{Unused1, UnusedToo1} // error // error
+  def foo() = outer1.unusedToo1 // in this case UnusedToo1 is not used explicitly, only inferred
+}

From 632a396fd87c24a1aac21a58e98f21c7496fd71e Mon Sep 17 00:00:00 2001
From: Szymon Rodziewicz <szymonrodant@gmail.com>
Date: Mon, 13 Mar 2023 15:11:53 +0100
Subject: [PATCH 07/15] Fix WUnused with indents in derived code

---
 .../tools/dotc/transform/CheckUnused.scala      | 14 +++++++-------
 .../fatal-warnings/i15503i.scala                | 17 +++++++++++++++++
 2 files changed, 24 insertions(+), 7 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
index 48f94cdc5211..513de32224c4 100644
--- a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
@@ -15,19 +15,14 @@ import dotty.tools.dotc.reporting.Message
 import dotty.tools.dotc.typer.ImportInfo
 import dotty.tools.dotc.util.{Property, SrcPos}
 import dotty.tools.dotc.core.Mode
-import dotty.tools.dotc.core.Types.TypeTraverser
-import dotty.tools.dotc.core.Types.Type
-import dotty.tools.dotc.core.Types.AnnotatedType
+import dotty.tools.dotc.core.Types.{AnnotatedType, ConstantType, NameFilter, NoType, TermRef, Type, TypeTraverser}
 import dotty.tools.dotc.core.Flags.flagsString
 import dotty.tools.dotc.core.Flags
 import dotty.tools.dotc.core.Names.Name
 import dotty.tools.dotc.transform.MegaPhase.MiniPhase
 import dotty.tools.dotc.core.Annotations
 import dotty.tools.dotc.core.Definitions
-import dotty.tools.dotc.core.Types.ConstantType
 import dotty.tools.dotc.core.NameKinds.WildcardParamName
-import dotty.tools.dotc.core.Types.TermRef
-import dotty.tools.dotc.core.Types.NameFilter
 import dotty.tools.dotc.core.Symbols.Symbol
 
 
@@ -82,6 +77,12 @@ class CheckUnused extends MiniPhase:
 
   override def prepareForIdent(tree: tpd.Ident)(using Context): Context =
     if tree.symbol.exists then
+      val prefixes = LazyList.iterate(tree.typeOpt.normalizedPrefix)(_.normalizedPrefix).takeWhile(_ != NoType)
+      for {
+        prefix <- prefixes
+      } {
+        unusedDataApply(_.registerUsed(prefix.classSymbol, None))
+      }
       unusedDataApply(_.registerUsed(tree.symbol, Some(tree.name)))
     else if tree.hasType then
       unusedDataApply(_.registerUsed(tree.tpe.classSymbol, Some(tree.name)))
@@ -409,7 +410,6 @@ object CheckUnused:
       val kept = used.filterNot { t =>
         val (sym, isAccessible, optName) = t
         // keep the symbol for outer scope, if it matches **no** import
-
         // This is the first matching wildcard selector
         var selWildCard: Option[ImportSelector] = None
 
diff --git a/tests/neg-custom-args/fatal-warnings/i15503i.scala b/tests/neg-custom-args/fatal-warnings/i15503i.scala
index e0675a060fdb..93c67a20c610 100644
--- a/tests/neg-custom-args/fatal-warnings/i15503i.scala
+++ b/tests/neg-custom-args/fatal-warnings/i15503i.scala
@@ -165,3 +165,20 @@ package foo.test.i16925:
       i <- 1 to 2 if true
       _ = println(i) // OK
     } yield ()
+
+package foo.test.i16679:
+  object myPackage:
+    trait CaseClassName[A]:
+      def name: String
+    object CaseClassName:
+      trait CaseClassByStringName[A] extends CaseClassName[A]
+      import scala.deriving.Mirror
+      object CaseClassByStringName:
+        inline final def derived[A](using inline A: Mirror.Of[A]): CaseClassByStringName[A] =
+          new CaseClassByStringName[A]:
+            def name: String = A.toString
+
+  object secondPackage:
+    import myPackage.CaseClassName // OK
+    case class CoolClass(i: Int) derives CaseClassName.CaseClassByStringName
+    println(summon[CaseClassName[CoolClass]].name)

From f37d3110b1c1dc4cfd822e760501f10a86cf8ea1 Mon Sep 17 00:00:00 2001
From: Szymon Rodziewicz <szymonrodant@gmail.com>
Date: Mon, 13 Mar 2023 15:38:12 +0100
Subject: [PATCH 08/15] Add failsafe for a case where prefixes in
 CheckUnused/prepareIndent formed an infinite cycle

---
 compiler/src/dotty/tools/dotc/transform/CheckUnused.scala | 1 +
 1 file changed, 1 insertion(+)

diff --git a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
index 513de32224c4..d990898c0508 100644
--- a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
@@ -78,6 +78,7 @@ class CheckUnused extends MiniPhase:
   override def prepareForIdent(tree: tpd.Ident)(using Context): Context =
     if tree.symbol.exists then
       val prefixes = LazyList.iterate(tree.typeOpt.normalizedPrefix)(_.normalizedPrefix).takeWhile(_ != NoType)
+        .take(10) // Failsafe for the odd case if there was an infinite cycle
       for {
         prefix <- prefixes
       } {

From 8b09ca7dc191c6c492503c42143425e34419f638 Mon Sep 17 00:00:00 2001
From: Szymon Rodziewicz <szymonrodant@gmail.com>
Date: Tue, 14 Mar 2023 15:53:10 +0100
Subject: [PATCH 09/15] Fix for formatting and traverse call of inlined tree in
 wunused

---
 .../src/dotty/tools/dotc/transform/CheckUnused.scala | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
index d990898c0508..ee0230216865 100644
--- a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
@@ -1,7 +1,7 @@
 package dotty.tools.dotc.transform
 
 import dotty.tools.dotc.ast.tpd
-import dotty.tools.dotc.ast.tpd.TreeTraverser
+import dotty.tools.dotc.ast.tpd.{Inlined, TreeTraverser}
 import dotty.tools.dotc.ast.untpd
 import dotty.tools.dotc.ast.untpd.ImportSelector
 import dotty.tools.dotc.config.ScalaSettings
@@ -59,6 +59,7 @@ class CheckUnused extends MiniPhase:
   // ========== SETUP ============
 
   override def prepareForUnit(tree: tpd.Tree)(using Context): Context =
+    println(tree)
     val data = UnusedData()
     val fresh = ctx.fresh.setProperty(_key, data)
     fresh
@@ -75,15 +76,16 @@ class CheckUnused extends MiniPhase:
     traverser.traverse(tree)
     ctx
 
+  def prepareForInlined(tree: Inlined)(using Context): Context =
+    traverser.traverse(tree.call)
+    ctx
+
   override def prepareForIdent(tree: tpd.Ident)(using Context): Context =
     if tree.symbol.exists then
       val prefixes = LazyList.iterate(tree.typeOpt.normalizedPrefix)(_.normalizedPrefix).takeWhile(_ != NoType)
         .take(10) // Failsafe for the odd case if there was an infinite cycle
-      for {
-        prefix <- prefixes
-      } {
+      for prefix <- prefixes do
         unusedDataApply(_.registerUsed(prefix.classSymbol, None))
-      }
       unusedDataApply(_.registerUsed(tree.symbol, Some(tree.name)))
     else if tree.hasType then
       unusedDataApply(_.registerUsed(tree.tpe.classSymbol, Some(tree.name)))

From bca861d2f40d724678f1e25e425d70f4350f83a9 Mon Sep 17 00:00:00 2001
From: Szymon Rodziewicz <szymonrodant@gmail.com>
Date: Tue, 14 Mar 2023 16:11:07 +0100
Subject: [PATCH 10/15] Add test for wunused Inlined call

---
 .../tools/dotc/transform/CheckUnused.scala    |  3 +--
 .../fatal-warnings/i15503i.scala              | 22 ++++++++++++++++++-
 2 files changed, 22 insertions(+), 3 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
index ee0230216865..e18341b08c79 100644
--- a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
@@ -59,7 +59,6 @@ class CheckUnused extends MiniPhase:
   // ========== SETUP ============
 
   override def prepareForUnit(tree: tpd.Tree)(using Context): Context =
-    println(tree)
     val data = UnusedData()
     val fresh = ctx.fresh.setProperty(_key, data)
     fresh
@@ -76,7 +75,7 @@ class CheckUnused extends MiniPhase:
     traverser.traverse(tree)
     ctx
 
-  def prepareForInlined(tree: Inlined)(using Context): Context =
+  override def prepareForInlined(tree: tpd.Inlined)(using Context): Context =
     traverser.traverse(tree.call)
     ctx
 
diff --git a/tests/neg-custom-args/fatal-warnings/i15503i.scala b/tests/neg-custom-args/fatal-warnings/i15503i.scala
index 93c67a20c610..d7793221f2d9 100644
--- a/tests/neg-custom-args/fatal-warnings/i15503i.scala
+++ b/tests/neg-custom-args/fatal-warnings/i15503i.scala
@@ -166,7 +166,7 @@ package foo.test.i16925:
       _ = println(i) // OK
     } yield ()
 
-package foo.test.i16679:
+package foo.test.i16679a:
   object myPackage:
     trait CaseClassName[A]:
       def name: String
@@ -182,3 +182,23 @@ package foo.test.i16679:
     import myPackage.CaseClassName // OK
     case class CoolClass(i: Int) derives CaseClassName.CaseClassByStringName
     println(summon[CaseClassName[CoolClass]].name)
+
+package foo.test.i16679b:
+  object myPackage:
+    trait CaseClassName[A]:
+      def name: String
+
+    object CaseClassName:
+      import scala.deriving.Mirror
+      inline final def derived[A](using inline A: Mirror.Of[A]): CaseClassName[A] =
+        new CaseClassName[A]:
+          def name: String = A.toString
+
+  object Foo:
+    given x: myPackage.CaseClassName[secondPackage.CoolClass] = null
+
+  object secondPackage:
+    import myPackage.CaseClassName // OK
+    import Foo.x
+    case class CoolClass(i: Int)
+    println(summon[myPackage.CaseClassName[CoolClass]])

From 5fe42828800695567904031c5f4b0f40d88b4e94 Mon Sep 17 00:00:00 2001
From: Szymon Rodziewicz <szymonrodant@gmail.com>
Date: Mon, 27 Mar 2023 16:49:09 +0200
Subject: [PATCH 11/15] Fix wunused false positive when deriving alias type

---
 .../src/dotty/tools/dotc/transform/CheckUnused.scala | 12 ++++++++++--
 libste                                               |  0
 2 files changed, 10 insertions(+), 2 deletions(-)
 create mode 100644 libste

diff --git a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
index e18341b08c79..556758ec51e2 100644
--- a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
@@ -565,14 +565,22 @@ object CheckUnused:
       /** Given an import and accessibility, return an option of selector that match import<->symbol */
       private def isInImport(imp: tpd.Import, isAccessible: Boolean, symName: Option[Name])(using Context): Option[ImportSelector] =
         val tpd.Import(qual, sels) = imp
-        val qualHasSymbol = qual.tpe.member(sym.name).alternatives.map(_.symbol).contains(sym)
+        val dealiasedSym = dealias(sym)
+        val qualHasSymbol = qual.tpe.member(sym.name).alternatives.map(_.symbol).map(dealias).contains(dealiasedSym)
         def selector = sels.find(sel => (sel.name.toTermName == sym.name || sel.name.toTypeName == sym.name) && symName.map(n => n.toTermName == sel.rename).getOrElse(true))
+        def dealiasedSelector = sels.flatMap(sel => qual.tpe.member(sym.name).alternatives.map(m => (sel, m.symbol))).collect {
+          case (sel, sym) if dealias(sym) == dealiasedSym => sel
+        }.headOption
         def wildcard = sels.find(sel => sel.isWildcard && ((sym.is(Given) == sel.isGiven) || sym.is(Implicit)))
         if qualHasSymbol && !isAccessible && sym.exists then
-          selector.orElse(wildcard) // selector with name or wildcard (or given)
+          selector.orElse(dealiasedSelector).orElse(wildcard) // selector with name or wildcard (or given)
         else
           None
 
+      private def dealias(symbol: Symbol)(using Context): Symbol =
+        if(symbol.isType && symbol.asType.denot.isAliasType) then
+          symbol.asType.typeRef.dealias.typeSymbol
+        else symbol
       /** Annotated with @unused */
       private def isUnusedAnnot(using Context): Boolean =
         sym.annotations.exists(a => a.symbol == ctx.definitions.UnusedAnnot)
diff --git a/libste b/libste
new file mode 100644
index 000000000000..e69de29bb2d1

From 3e40030270b486c13c19075f964e357f91683d50 Mon Sep 17 00:00:00 2001
From: Szymon Rodziewicz <szymonrodant@gmail.com>
Date: Mon, 3 Apr 2023 15:53:05 +0200
Subject: [PATCH 12/15] Fix wunused for deriving alias type that has a
 different name

---
 .../src/dotty/tools/dotc/transform/CheckUnused.scala  |  7 +++++--
 libste                                                |  0
 tests/neg-custom-args/fatal-warnings/i15503i.scala    | 11 +++++++++++
 3 files changed, 16 insertions(+), 2 deletions(-)
 delete mode 100644 libste

diff --git a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
index 556758ec51e2..f48dbe7c46bb 100644
--- a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
@@ -566,9 +566,12 @@ object CheckUnused:
       private def isInImport(imp: tpd.Import, isAccessible: Boolean, symName: Option[Name])(using Context): Option[ImportSelector] =
         val tpd.Import(qual, sels) = imp
         val dealiasedSym = dealias(sym)
-        val qualHasSymbol = qual.tpe.member(sym.name).alternatives.map(_.symbol).map(dealias).contains(dealiasedSym)
+        val typeSelections = sels.flatMap(n => qual.tpe.member(n.name.toTypeName).alternatives)
+        val termSelections = sels.flatMap(n => qual.tpe.member(n.name.toTermName).alternatives)
+        val allSelections = typeSelections ::: termSelections :::qual.tpe.member(sym.name).alternatives
+        val qualHasSymbol = allSelections.map(_.symbol).map(dealias).contains(dealiasedSym)
         def selector = sels.find(sel => (sel.name.toTermName == sym.name || sel.name.toTypeName == sym.name) && symName.map(n => n.toTermName == sel.rename).getOrElse(true))
-        def dealiasedSelector = sels.flatMap(sel => qual.tpe.member(sym.name).alternatives.map(m => (sel, m.symbol))).collect {
+        def dealiasedSelector = sels.flatMap(sel => allSelections.map(m => (sel, m.symbol))).collect {
           case (sel, sym) if dealias(sym) == dealiasedSym => sel
         }.headOption
         def wildcard = sels.find(sel => sel.isWildcard && ((sym.is(Given) == sel.isGiven) || sym.is(Implicit)))
diff --git a/libste b/libste
deleted file mode 100644
index e69de29bb2d1..000000000000
diff --git a/tests/neg-custom-args/fatal-warnings/i15503i.scala b/tests/neg-custom-args/fatal-warnings/i15503i.scala
index d7793221f2d9..94e3cde8be5c 100644
--- a/tests/neg-custom-args/fatal-warnings/i15503i.scala
+++ b/tests/neg-custom-args/fatal-warnings/i15503i.scala
@@ -202,3 +202,14 @@ package foo.test.i16679b:
     import Foo.x
     case class CoolClass(i: Int)
     println(summon[myPackage.CaseClassName[CoolClass]])
+
+package foo.test.i17156:
+  package a:
+    trait Foo[A]
+
+  package b:
+    type Xd = Foo
+
+  package c:
+    import b.Xd
+    trait Z derives Xd

From 7fdf1b3206c42f636dfb168528409b2401ad0aa3 Mon Sep 17 00:00:00 2001
From: Szymon Rodziewicz <szymonrodant@gmail.com>
Date: Mon, 3 Apr 2023 19:45:58 +0200
Subject: [PATCH 13/15] Fix test for wunused alias deriving

---
 tests/neg-custom-args/fatal-warnings/i15503i.scala | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/tests/neg-custom-args/fatal-warnings/i15503i.scala b/tests/neg-custom-args/fatal-warnings/i15503i.scala
index 94e3cde8be5c..dc473b74e0f6 100644
--- a/tests/neg-custom-args/fatal-warnings/i15503i.scala
+++ b/tests/neg-custom-args/fatal-warnings/i15503i.scala
@@ -206,9 +206,12 @@ package foo.test.i16679b:
 package foo.test.i17156:
   package a:
     trait Foo[A]
+    object Foo:
+      inline def derived[T]: Foo[T] = new Foo{}
 
   package b:
-    type Xd = Foo
+    import a.Foo
+    type Xd[A] = Foo[A]
 
   package c:
     import b.Xd

From d51845b0e50cabce696c1f943b446215d6c8d6ae Mon Sep 17 00:00:00 2001
From: Szymon Rodziewicz <szymonrodant@gmail.com>
Date: Tue, 4 Apr 2023 14:43:12 +0200
Subject: [PATCH 14/15] Fix selecting unaliased selector in wunused

---
 compiler/src/dotty/tools/dotc/transform/CheckUnused.scala | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
index f48dbe7c46bb..6b0cba4c6062 100644
--- a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
@@ -566,12 +566,13 @@ object CheckUnused:
       private def isInImport(imp: tpd.Import, isAccessible: Boolean, symName: Option[Name])(using Context): Option[ImportSelector] =
         val tpd.Import(qual, sels) = imp
         val dealiasedSym = dealias(sym)
+        val simpleSelections = qual.tpe.member(sym.name).alternatives
         val typeSelections = sels.flatMap(n => qual.tpe.member(n.name.toTypeName).alternatives)
         val termSelections = sels.flatMap(n => qual.tpe.member(n.name.toTermName).alternatives)
-        val allSelections = typeSelections ::: termSelections :::qual.tpe.member(sym.name).alternatives
-        val qualHasSymbol = allSelections.map(_.symbol).map(dealias).contains(dealiasedSym)
+        val selectionsToDealias = typeSelections ::: termSelections
+        val qualHasSymbol = simpleSelections.map(_.symbol).contains(sym) || (simpleSelections ::: selectionsToDealias).map(_.symbol).map(dealias).contains(dealiasedSym)
         def selector = sels.find(sel => (sel.name.toTermName == sym.name || sel.name.toTypeName == sym.name) && symName.map(n => n.toTermName == sel.rename).getOrElse(true))
-        def dealiasedSelector = sels.flatMap(sel => allSelections.map(m => (sel, m.symbol))).collect {
+        def dealiasedSelector = sels.flatMap(sel => selectionsToDealias.map(m => (sel, m.symbol))).collect {
           case (sel, sym) if dealias(sym) == dealiasedSym => sel
         }.headOption
         def wildcard = sels.find(sel => sel.isWildcard && ((sym.is(Given) == sel.isGiven) || sym.is(Implicit)))
@@ -580,6 +581,7 @@ object CheckUnused:
         else
           None
 
+
       private def dealias(symbol: Symbol)(using Context): Symbol =
         if(symbol.isType && symbol.asType.denot.isAliasType) then
           symbol.asType.typeRef.dealias.typeSymbol

From 78ba15fd2c922318ae7bf7ae4b7eb4a4b83f3339 Mon Sep 17 00:00:00 2001
From: Szymon Rodziewicz <szymonrodant@gmail.com>
Date: Mon, 10 Apr 2023 19:41:15 +0200
Subject: [PATCH 15/15] Dealias only conditionally when symbol is derived val
 type in wunused

---
 .../tools/dotc/transform/CheckUnused.scala    | 27 ++++++++++---------
 1 file changed, 15 insertions(+), 12 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
index 6b0cba4c6062..3490a95c58b8 100644
--- a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
+++ b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
@@ -24,7 +24,7 @@ import dotty.tools.dotc.core.Annotations
 import dotty.tools.dotc.core.Definitions
 import dotty.tools.dotc.core.NameKinds.WildcardParamName
 import dotty.tools.dotc.core.Symbols.Symbol
-
+import dotty.tools.dotc.core.StdNames.nme
 
 
 /**
@@ -109,6 +109,9 @@ class CheckUnused extends MiniPhase:
       traverseAnnotations(tree.symbol)
       if !tree.symbol.is(Module) then
         ud.registerDef(tree)
+      if tree.name.mangledString.startsWith(nme.derived.mangledString + "$")
+          && tree.typeOpt != NoType then
+        ud.registerUsed(tree.typeOpt.typeSymbol, None, true)
       ud.addIgnoredUsage(tree.symbol)
     }
 
@@ -304,7 +307,7 @@ object CheckUnused:
      *
      * See the `isAccessibleAsIdent` extension method below in the file
      */
-    private val usedInScope = MutStack(MutSet[(Symbol,Boolean, Option[Name])]())
+    private val usedInScope = MutStack(MutSet[(Symbol,Boolean, Option[Name], Boolean)]())
     private val usedInPosition = MutSet[(SrcPos, Name)]()
     /* unused import collected during traversal */
     private val unusedImport = MutSet[ImportSelector]()
@@ -347,14 +350,14 @@ object CheckUnused:
      * The optional name will be used to target the right import
      * as the same element can be imported with different renaming
      */
-    def registerUsed(sym: Symbol, name: Option[Name])(using Context): Unit =
+    def registerUsed(sym: Symbol, name: Option[Name], isDerived: Boolean = false)(using Context): Unit =
       if !isConstructorOfSynth(sym) && !doNotRegister(sym) then
         if sym.isConstructor && sym.exists then
           registerUsed(sym.owner, None) // constructor are "implicitly" imported with the class
         else
-          usedInScope.top += ((sym, sym.isAccessibleAsIdent, name))
-          usedInScope.top += ((sym.companionModule, sym.isAccessibleAsIdent, name))
-          usedInScope.top += ((sym.companionClass, sym.isAccessibleAsIdent, name))
+          usedInScope.top += ((sym, sym.isAccessibleAsIdent, name, isDerived))
+          usedInScope.top += ((sym.companionModule, sym.isAccessibleAsIdent, name, isDerived))
+          usedInScope.top += ((sym.companionClass, sym.isAccessibleAsIdent, name, isDerived))
           name.map(n => usedInPosition += ((sym.sourcePos, n)))
 
     /** Register a symbol that should be ignored */
@@ -408,15 +411,15 @@ object CheckUnused:
       // used symbol in this scope
       val used = usedInScope.pop().toSet
       // used imports in this scope
-      val imports = impInScope.pop().toSet
+      val imports = impInScope.pop()
       val kept = used.filterNot { t =>
-        val (sym, isAccessible, optName) = t
+        val (sym, isAccessible, optName, isDerived) = t
         // keep the symbol for outer scope, if it matches **no** import
         // This is the first matching wildcard selector
         var selWildCard: Option[ImportSelector] = None
 
         val exists = imports.exists { imp =>
-          sym.isInImport(imp, isAccessible, optName) match
+          sym.isInImport(imp, isAccessible, optName, isDerived) match
             case None => false
             case optSel@Some(sel) if sel.isWildcard =>
               if selWildCard.isEmpty then selWildCard = optSel
@@ -563,7 +566,7 @@ object CheckUnused:
           }
 
       /** Given an import and accessibility, return an option of selector that match import<->symbol */
-      private def isInImport(imp: tpd.Import, isAccessible: Boolean, symName: Option[Name])(using Context): Option[ImportSelector] =
+      private def isInImport(imp: tpd.Import, isAccessible: Boolean, symName: Option[Name], isDerived: Boolean)(using Context): Option[ImportSelector] =
         val tpd.Import(qual, sels) = imp
         val dealiasedSym = dealias(sym)
         val simpleSelections = qual.tpe.member(sym.name).alternatives
@@ -572,9 +575,9 @@ object CheckUnused:
         val selectionsToDealias = typeSelections ::: termSelections
         val qualHasSymbol = simpleSelections.map(_.symbol).contains(sym) || (simpleSelections ::: selectionsToDealias).map(_.symbol).map(dealias).contains(dealiasedSym)
         def selector = sels.find(sel => (sel.name.toTermName == sym.name || sel.name.toTypeName == sym.name) && symName.map(n => n.toTermName == sel.rename).getOrElse(true))
-        def dealiasedSelector = sels.flatMap(sel => selectionsToDealias.map(m => (sel, m.symbol))).collect {
+        def dealiasedSelector = if(isDerived) sels.flatMap(sel => selectionsToDealias.map(m => (sel, m.symbol))).collect {
           case (sel, sym) if dealias(sym) == dealiasedSym => sel
-        }.headOption
+        }.headOption else None
         def wildcard = sels.find(sel => sel.isWildcard && ((sym.is(Given) == sel.isGiven) || sym.is(Implicit)))
         if qualHasSymbol && !isAccessible && sym.exists then
           selector.orElse(dealiasedSelector).orElse(wildcard) // selector with name or wildcard (or given)