diff --git a/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala b/compiler/src/dotty/tools/dotc/transform/CheckUnused.scala
index e7e6e1c4952c..5e4ed6f6e0df 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
@@ -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, 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
 
 
@@ -80,8 +75,16 @@ class CheckUnused extends MiniPhase:
     traverser.traverse(tree)
     ctx
 
+  override def prepareForInlined(tree: tpd.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 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)))
@@ -409,7 +412,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 ab83e1dafb3b..3dd4d1fc61e7 100644
--- a/tests/neg-custom-args/fatal-warnings/i15503i.scala
+++ b/tests/neg-custom-args/fatal-warnings/i15503i.scala
@@ -207,4 +207,41 @@ package foo.test.i16925:
     for {
       i <- 1 to 2 if true
       _ = println(i) // OK
-    } yield ()
\ No newline at end of file
+    } yield ()
+
+package foo.test.i16679a:
+  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)
+
+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]])