fix import shadowing

Author: rochala

compiler/src/dotty/tools/repl/CollectTopLevelImports.scala

@@ -18,6 +18,7 @@ import dotty.tools.dotc.util.Spans._
 import dotty.tools.dotc.util.{ParsedComment, Property, SourceFile}
 import dotty.tools.dotc.{CompilationUnit, Compiler, Run}
 import dotty.tools.repl.results._
+import dotty.tools.repl.transform._
 
 import scala.collection.mutable
 import scala.util.chaining.given

compiler/src/dotty/tools/repl/ReplCompiler.scala

@@ -31,6 +31,7 @@ import dotty.tools.dotc.util.{SourceFile, SourcePosition}
 import dotty.tools.dotc.{CompilationUnit, Driver}
 import dotty.tools.dotc.config.CompilerCommand
 import dotty.tools.io._
+import dotty.tools.repl.transform._
 import dotty.tools.runner.ScalaClassLoader.*
 import org.jline.reader._
 

compiler/src/dotty/tools/repl/ReplDriver.scala

@@ -0,0 +1,73 @@
+package dotty.tools.repl.transform
+
+import dotty.tools.dotc.ast.tpd
+import dotty.tools.dotc.ast.untpd
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.core.Names.Name
+import dotty.tools.dotc.core.Phases.Phase
+import dotty.tools.dotc.core.StdNames.ScalaTermNames
+
+
+/** This phase collects and transforms top-level Import trees to handle definition shadowing.
+ *
+ *  This is used by repl to handle new run contexts and allowing
+ *  definitions to be shadowed by imports in the same run.
+ *
+ *  Import transformation is necessary for excluding its members when they are shadowed in the same run.
+ *  This is done by finding all members defined after the Import clause calculating
+ *  their intersection with available members from selectors
+ *
+ *  This step is necessary for proper new run initialization since we need to import the previous run
+ *  into Context. It is accomplished in the following order:
+ *    1. Previous wrapper object for a given run
+ *    2. Previous imports for a given run
+ *
+ *  This phase uses typed trees thus after the Typer phase.
+ */
+class CollectTopLevelImports extends Phase {
+  import tpd._
+
+  def phaseName: String = "collectTopLevelImports"
+
+  private var gatheredImports: List[Import] = _
+
+  def imports: List[Import] = gatheredImports
+
+  def run(using Context): Unit =
+    val PackageDef(_, _ :: TypeDef(_, rhs: Template) :: _) = ctx.compilationUnit.tpdTree: @unchecked
+    gatheredImports = transformTopLevelImports(rhs.body)
+
+  /** Transforms top-level imports to exclude intersecting members declared after the Import clause.
+   *  To properly handle imports such as: `import A.f; def f = 3`  consequently making sure that original selectors are
+   *  filtered to eliminate potential duplications that would result in compilation error.
+   */
+  private def transformTopLevelImports(trees: List[Tree])(using Context): List[Import] =
+    val definitions = collectTopLevelMemberDefs(trees)
+
+    trees.collect {
+      case tree @ Import(expr, selectors) =>
+        val definitionsAfterImport = definitions.filter(_._2 > tree.endPos.end).map(_._1)
+        val membersIntersection = expr.tpe.allMembers.map(_.name).intersect(definitionsAfterImport)
+
+        val transformedSelectors = membersIntersection.map(collidingMember => {
+          untpd.ImportSelector(untpd.Ident(collidingMember), untpd.Ident(CollectTopLevelImports.nme.WILDCARD))
+        }).toList
+
+        val filteredSelectors = selectors.filterNot(importSelector => membersIntersection.contains(importSelector.imported.name))
+
+        Import(expr, transformedSelectors.toList  ::: filteredSelectors)
+    }
+
+  private def collectTopLevelMemberDefs(trees: List[Tree])(using Context): List[(Name, Int)] =
+    trees.collect {
+      case tree: ValDef  => tree.name -> tree.endPos.end
+      case tree: DefDef  => tree.name -> tree.endPos.end
+      case tree: TypeDef => tree.name -> tree.endPos.end
+    }
+
+}
+
+object CollectTopLevelImports {
+  private lazy val nme: ScalaTermNames = new ScalaTermNames
+}
+

compiler/src/dotty/tools/repl/transform/CollectTopLevelImports.scala

@@ -25,3 +25,31 @@ def f: Int
 
 scala> val x3 = f
 val x3: Int = 1
+
+scala> import A._; def f = 5
+def f: Int
+
+scala> val x4 = f
+val x4: Int = 5
+
+scala> def f = 6; println(f); import A._; println(f);  // import shadowing should only work on toplevel definitions in next runs
+6
+6
+def f: Int
+
+scala> import A._; println(f); def f = 7; println(f)
+7
+7
+def f: Int
+
+scala> def f = 8; import A.f
+def f: Int
+
+scala> val x5 = f
+val x5: Int = 1
+
+scala> import A.f; def f = 9
+def f: Int
+
+scala> val x6 = f
+val x6: Int = 9