fix: don't look for overshadow conflicts for symbols not in the scope

[Cherry-picked 6187ac0]

Author: kasiaMarek

presentation-compiler/src/main/dotty/tools/pc/PcInlineValueProviderImpl.scala

@@ -18,6 +18,7 @@ import dotty.tools.dotc.interactive.Interactive
 import dotty.tools.dotc.interactive.InteractiveDriver
 import dotty.tools.dotc.util.SourcePosition
 import dotty.tools.pc.utils.InteractiveEnrichments.*
+import dotty.tools.pc.IndexedContext.Result
 
 import org.eclipse.lsp4j as l
 
@@ -49,7 +50,9 @@ final class PcInlineValueProviderImpl(
           DefinitionTree(defn, pos)
         }
         .toRight(Errors.didNotFindDefinition)
-      symbols = symbolsUsedInDefn(definition.tree.rhs)
+      path = Interactive.pathTo(unit.tpdTree, definition.tree.rhs.span)(using newctx)
+      indexedContext = IndexedContext(Interactive.contextOfPath(path)(using newctx))
+      symbols = symbolsUsedInDefn(definition.tree.rhs).filter(indexedContext.lookupSym(_) == Result.InScope)
       references <- getReferencesToInline(definition, allOccurences, symbols)
     yield
       val (deleteDefinition, refsEdits) = references
@@ -111,27 +114,25 @@ final class PcInlineValueProviderImpl(
     val adjustedEnd = extend(pos.end - 1, ')', 1) + 1
     text.slice(adjustedStart, adjustedEnd).mkString
 
-  private def symbolsUsedInDefn(
-      rhs: Tree
-  ): List[Symbol] =
+  private def symbolsUsedInDefn(rhs: Tree): Set[Symbol] =
     def collectNames(
-        symbols: List[Symbol],
+        symbols: Set[Symbol],
         tree: Tree
-    ): List[Symbol] =
+    ): Set[Symbol] =
       tree match
         case id: (Ident | Select)
             if !id.symbol.is(Synthetic) && !id.symbol.is(Implicit) =>
-          tree.symbol :: symbols
+          symbols + tree.symbol
         case _ => symbols
 
-    val traverser = new DeepFolder[List[Symbol]](collectNames)
-    traverser(List(), rhs)
+    val traverser = new DeepFolder[Set[Symbol]](collectNames)
+    traverser(Set(), rhs)
   end symbolsUsedInDefn
 
   private def getReferencesToInline(
       definition: DefinitionTree,
       allOccurences: List[Occurence],
-      symbols: List[Symbol]
+      symbols: Set[Symbol]
   ): Either[String, (Boolean, List[Reference])] =
     val defIsLocal = definition.tree.symbol.ownersIterator
       .drop(1)
@@ -156,7 +157,7 @@ final class PcInlineValueProviderImpl(
 
   private def makeRefsEdits(
       refs: List[Occurence],
-      symbols: List[Symbol]
+      symbols: Set[Symbol]
   ): Either[String, List[Reference]] =
     val newctx = driver.currentCtx.fresh.setCompilationUnit(unit)
     def buildRef(occurrence: Occurence): Either[String, Reference] =

presentation-compiler/test/dotty/tools/pc/tests/edit/InlineValueSuite.scala

@@ -301,6 +301,47 @@ class InlineValueSuite extends BaseCodeActionSuite with CommonMtagsEnrichments:
          |}""".stripMargin
     )
 
+
+  @Test def `i6924` =
+    checkEdit(
+      """|object O {
+         |  def test(n: Int) = {
+         |    val isOne = n == 1
+         |    <<i>>sOne
+         |  }
+         |}
+         |""".stripMargin,
+      """|object O {
+         |  def test(n: Int) = {
+         |    n == 1
+         |  }
+         |}
+         |""".stripMargin
+    )
+
+  @Test def `i6924-2` =
+    checkEdit(
+      """|object O {
+         |  def ==(o: O) = false
+         |}
+         |object P {
+         |  def test() = {
+         |    val isOne = O == O
+         |    <<i>>sOne
+         |  }
+         |}
+         |""".stripMargin,
+      """|object O {
+         |  def ==(o: O) = false
+         |}
+         |object P {
+         |  def test() = {
+         |    O == O
+         |  }
+         |}
+         |""".stripMargin
+    )
+
   @Test def `scoping-packages` =
     checkError(
       """|package a
@@ -346,6 +387,26 @@ class InlineValueSuite extends BaseCodeActionSuite with CommonMtagsEnrichments:
       InlineErrors.variablesAreShadowed("A.k")
     )
 
+  @Test def `bad-scoping-3` =
+    checkError(
+      """|class T {
+         |    val a = 1
+         |}
+         |
+         |class O {
+         |  val t = new T()
+         |  import t._
+         |  val bb = a + a
+         |
+         |  class Inner {
+         |    val a = 123
+         |    val cc = <<b>>b
+         |  }
+         |}
+         |""".stripMargin,
+      InlineErrors.variablesAreShadowed("T.a")
+    )
+
   def checkEdit(
       original: String,
       expected: String,