Backport "Fix WUnused with idents in derived code"

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

@@ -1,33 +1,29 @@
 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
 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, 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
 
 
 
@@ -46,12 +42,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
 
@@ -71,7 +66,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 ==========
@@ -80,16 +75,24 @@ 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 
-      _key.unusedDataApply(_.registerUsed(tree.symbol, Some(tree.name)))
+    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
-      _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)
@@ -101,33 +104,37 @@ 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`
-      if !tree.symbol.is(Module) then 
+      traverseAnnotations(tree.symbol)
+      if !tree.symbol.is(Module) then
         ud.registerDef(tree)
       ud.addIgnoredUsage(tree.symbol)
     }
 
   override def prepareForDefDef(tree: tpd.DefDef)(using Context): Context =
-    _key.unusedDataApply{ ud =>
+    unusedDataApply{ ud =>
       import ud.registerTrivial
       tree.registerTrivial
+      traverseAnnotations(tree.symbol)
       ud.registerDef(tree)
       ud.addIgnoredUsage(tree.symbol)
     }
 
   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)
         ud.addIgnoredUsage(tree.symbol)
     }
 
   override def prepareForBind(tree: tpd.Bind)(using Context): Context =
-    _key.unusedDataApply(_.registerPatVar(tree))
+    traverseAnnotations(tree.symbol)
+    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 ==========
@@ -145,27 +152,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
@@ -188,7 +195,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)
@@ -198,7 +205,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 =>
@@ -216,9 +223,10 @@ class CheckUnused extends MiniPhase:
         case t: tpd.Bind =>
           prepareForBind(t)
           traverseChildren(tree)(using newCtx)
+        case _: tpd.InferredTypeTree =>
         case [email protected]() =>
           //! DIFFERS FROM MINIPHASE
-          typeTraverser(_key.unusedDataApply).traverse(t.tpe)
+          typeTraverser(unusedDataApply).traverse(t.tpe)
           traverseChildren(tree)(using newCtx)
         case _ =>
           //! DIFFERS FROM MINIPHASE
@@ -228,9 +236,18 @@ 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 =
+    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 =
@@ -274,7 +291,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 */
@@ -289,6 +305,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]()
 
@@ -324,25 +341,21 @@ 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
      *
      * 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
         else
           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 =
@@ -363,22 +376,19 @@ 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
             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
 
     /** Register pattern variable */
     def registerPatVar(patvar: tpd.Bind)(using Context): Unit =
-      registerUsedAnnotation(patvar.symbol)
       if !patvar.symbol.isUnusedAnnot then
         patVarsInScope += patvar
 
@@ -402,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
 
@@ -450,6 +459,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 +488,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
@@ -578,10 +589,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 +625,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)