Always resolve but restrict imports

Author: som-snytt

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

@@ -1,29 +1,26 @@
-package dotty.tools.dotc.transform
-
-import dotty.tools.dotc.ast.desugar.{ForArtifact, PatternVar}
-import dotty.tools.dotc.ast.tpd.*
-import dotty.tools.dotc.ast.untpd, untpd.ImportSelector
-import dotty.tools.dotc.config.ScalaSettings
-import dotty.tools.dotc.core.Contexts.*
-import dotty.tools.dotc.core.Flags.*
-import dotty.tools.dotc.core.Names.{Name, SimpleName, DerivedName, TermName, termName}
-import dotty.tools.dotc.core.NameKinds.{
-  BodyRetainerName, ContextBoundParamName, ContextFunctionParamName, DefaultGetterName, WildcardParamName}
-import dotty.tools.dotc.core.NameOps.{isAnonymousFunctionName, isReplWrapperName, setterName}
-import dotty.tools.dotc.core.Scopes.newScope
-import dotty.tools.dotc.core.StdNames.nme
-import dotty.tools.dotc.core.Symbols.{ClassSymbol, NoSymbol, Symbol, defn, isDeprecated, requiredClass, requiredModule}
-import dotty.tools.dotc.core.Types.*
-import dotty.tools.dotc.report
-import dotty.tools.dotc.reporting.{CodeAction, UnusedSymbol}
-import dotty.tools.dotc.rewrites.Rewrites
-import dotty.tools.dotc.transform.MegaPhase.MiniPhase
-import dotty.tools.dotc.typer.{ImportInfo, Typer}
-import dotty.tools.dotc.typer.Deriving.OriginalTypeClass
-import dotty.tools.dotc.typer.Implicits.{ContextualImplicits, RenamedImplicitRef}
-import dotty.tools.dotc.util.{Property, Spans, SrcPos}, Spans.Span
-import dotty.tools.dotc.util.Chars.{isLineBreakChar, isWhitespace}
-import dotty.tools.dotc.util.chaining.*
+package dotty.tools.dotc
+package transform
+
+import ast.*, desugar.{ForArtifact, PatternVar}, tpd.*, untpd.ImportSelector
+import config.ScalaSettings
+import core.*, Contexts.*, Flags.*
+import Names.{Name, SimpleName, DerivedName, TermName, termName}
+import NameKinds.{BodyRetainerName, ContextBoundParamName, ContextFunctionParamName, DefaultGetterName, WildcardParamName}
+import NameOps.{isAnonymousFunctionName, isReplWrapperName, setterName}
+import Scopes.newScope
+import StdNames.nme
+import Symbols.{ClassSymbol, NoSymbol, Symbol, defn, isDeprecated, requiredClass, requiredModule}
+import Types.*
+import reporting.{CodeAction, UnusedSymbol}
+import rewrites.Rewrites
+
+import MegaPhase.MiniPhase
+import typer.{ImportInfo, Typer}
+import typer.Deriving.OriginalTypeClass
+import typer.Implicits.{ContextualImplicits, RenamedImplicitRef}
+import util.{Property, Spans, SrcPos}, Spans.Span
+import util.Chars.{isLineBreakChar, isWhitespace}
+import util.chaining.*
 
 import java.util.IdentityHashMap
 
@@ -60,14 +57,14 @@ class CheckUnused private (phaseMode: PhaseMode, suffix: String) extends MiniPha
       val resolving =
            tree.srcPos.isUserCode
         || tree.srcPos.isZeroExtentSynthetic // take as summonInline
-      if resolving && !ignoreTree(tree) then
+      if !ignoreTree(tree) then
         def loopOverPrefixes(prefix: Type, depth: Int): Unit =
           if depth < 10 && prefix.exists && !prefix.classSymbol.isEffectiveRoot then
-            resolveUsage(prefix.classSymbol, nme.NO_NAME, NoPrefix)
+            resolveUsage(prefix.classSymbol, nme.NO_NAME, NoPrefix, imports = resolving)
             loopOverPrefixes(prefix.normalizedPrefix, depth + 1)
         if tree.srcPos.isZeroExtentSynthetic then
           loopOverPrefixes(tree.typeOpt.normalizedPrefix, depth = 0)
-        resolveUsage(tree.symbol, tree.name, tree.typeOpt.importPrefix.skipPackageObject)
+        resolveUsage(tree.symbol, tree.name, tree.typeOpt.importPrefix.skipPackageObject, imports = resolving)
     else if tree.hasType then
       resolveUsage(tree.tpe.classSymbol, tree.name, tree.tpe.importPrefix.skipPackageObject)
     refInfos.isAssignment = false
@@ -318,8 +315,11 @@ class CheckUnused private (phaseMode: PhaseMode, suffix: String) extends MiniPha
    *  e.g., in `scala.Int`, `scala` is in scope for typer, but here we reverse-engineer the attribution.
    *  For Select, lint does not look up `<empty>.scala` (so top-level syms look like magic) but records `scala.Int`.
    *  For Ident, look-up finds the root import as usual. A competing import is OK because higher precedence.
+   *
+   *  The `imports` flag is whether an identifier can mark an import as used: the flag is false
+   *  for inlined code, except for `summonInline` (and related constructs) which are resolved at inlining.
    */
-  def resolveUsage(sym0: Symbol, name: Name, prefix: Type)(using Context): Unit =
+  def resolveUsage(sym0: Symbol, name: Name, prefix: Type, imports: Boolean = true)(using Context): Unit =
     import PrecedenceLevels.*
     val sym = sym0.userSymbol
 
@@ -423,7 +423,7 @@ class CheckUnused private (phaseMode: PhaseMode, suffix: String) extends MiniPha
     // record usage and possibly an import
     if !enclosed then
       refInfos.addRef(sym)
-    if candidate != NoContext && candidate.isImportContext && importer != null then
+    if imports && candidate != NoContext && candidate.isImportContext && importer != null then
       refInfos.sels.put(importer, ())
   end resolveUsage