WUnused: Fix for symbols with synthetic names and unused transparent inlines

Author: szymon-rd

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

@@ -10,7 +10,7 @@ import dotty.tools.dotc.core.Decorators.{em, i}
 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.{ast, report}
 import dotty.tools.dotc.reporting.Message
 import dotty.tools.dotc.typer.ImportInfo
 import dotty.tools.dotc.util.{Property, SrcPos}
@@ -432,6 +432,20 @@ object CheckUnused:
         else
           exists
       }
+
+      // not report unused transparent inline imports
+      for {
+        imp <- imports
+        sel <- imp.selectors
+      } {
+        if unusedImport.contains(sel) then
+          val tpd.Import(qual, _) = imp
+          val importedMembers = qual.tpe.member(sel.name).alternatives.map(_.symbol)
+          val isTransparentAndInline = importedMembers.exists(s => s.is(Transparent) && s.is(Inline))
+          if isTransparentAndInline then
+            unusedImport -= sel
+      }
+
       // if there's an outer scope
       if usedInScope.nonEmpty then
         // we keep the symbols not referencing an import in this scope
@@ -450,6 +464,7 @@ object CheckUnused:
      */
     def getUnused(using Context): UnusedResult =
       popScope()
+
       val sortedImp =
         if ctx.settings.WunusedHas.imports || ctx.settings.WunusedHas.strictNoImplicitWarn then
           unusedImport.map(d => d.srcPos -> WarnTypes.Imports).toList
@@ -460,34 +475,39 @@ object CheckUnused:
           localDefInScope
             .filterNot(d => d.symbol.usedDefContains)
             .filterNot(d => usedInPosition.exists { case (pos, name) => d.span.contains(pos.span) && name == d.symbol.name})
+            .filterNot(d => containsSyntheticSuffix(d.symbol))
             .map(d => d.namePos -> WarnTypes.LocalDefs).toList
         else
           Nil
       val sortedExplicitParams =
         if ctx.settings.WunusedHas.explicits then
           explicitParamInScope
             .filterNot(d => d.symbol.usedDefContains)
+            .filterNot(d => containsSyntheticSuffix(d.symbol))
             .map(d => d.namePos -> WarnTypes.ExplicitParams).toList
         else
           Nil
       val sortedImplicitParams =
         if ctx.settings.WunusedHas.implicits then
           implicitParamInScope
             .filterNot(d => d.symbol.usedDefContains)
+            .filterNot(d => containsSyntheticSuffix(d.symbol))
             .map(d => d.namePos -> WarnTypes.ImplicitParams).toList
         else
           Nil
       val sortedPrivateDefs =
         if ctx.settings.WunusedHas.privates then
           privateDefInScope
             .filterNot(d => d.symbol.usedDefContains)
+            .filterNot(d => containsSyntheticSuffix(d.symbol))
             .map(d => d.namePos -> WarnTypes.PrivateMembers).toList
         else
           Nil
       val sortedPatVars =
         if ctx.settings.WunusedHas.patvars then
           patVarsInScope
             .filterNot(d => d.symbol.usedDefContains)
+            .filterNot(d => containsSyntheticSuffix(d.symbol))
             .filterNot(d => usedInPosition.exists { case (pos, name) => d.span.contains(pos.span) && name == d.symbol.name})
             .map(d => d.namePos -> WarnTypes.PatVars).toList
         else
@@ -500,6 +520,11 @@ object CheckUnused:
     end getUnused
     //============================ HELPERS ====================================
 
+    /**
+     * Heuristic to detect synthetic suffixes in names of symbols
+     */
+    private def containsSyntheticSuffix(symbol: Symbol)(using Context): Boolean =
+      symbol.name.mangledString.contains("$")
     /**
      * Is the the constructor of synthetic package object
      * Should be ignored as it is always imported/used in package

tests/neg-custom-args/fatal-warnings/i15503i.scala

@@ -209,6 +209,34 @@ package foo.test.i16925:
       _ = println(i) // OK
     } yield ()
 
+package foo.test.i16863a:
+  import scala.quoted.*
+  def fn(using Quotes) =
+    val x = Expr(1)
+    '{ $x + 2 } // OK
+
+package foo.test.i16863b:
+  import scala.quoted.*
+  def fn[A](using Quotes, Type[A]) = // OK
+    val numeric = Expr.summon[Numeric[A]].getOrElse(???)
+    '{ $numeric.fromInt(3) } // OK
+
+package foo.test.i16863c:
+  import scala.quoted.*
+  def fn[A](expr: Expr[Any])(using Quotes) =
+    val imp = expr match
+      case '{ ${ _ }: a } => Expr.summon[Numeric[a]] // OK
+    println(imp)
+
+package foo.test.i16863d:
+  import scala.quoted.*
+  import scala.compiletime.asMatchable // OK
+  def fn[A](using Quotes, Type[A]) =
+    import quotes.reflect.*
+    val imp = TypeRepr.of[A].widen.asMatchable match
+      case Refinement(_,_,_) => ()
+    println(imp)
+
 package foo.test.i16679a:
   object myPackage:
     trait CaseClassName[A]: