add missing renamed method shadowing, remove empty imports

Author: rochala

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

@@ -15,7 +15,7 @@ import dotty.tools.dotc.core.StdNames.ScalaTermNames
  *
  *  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
+ *  their intersection with available members from selectors including renaming.
  *
  *  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:
@@ -40,23 +40,38 @@ class CollectTopLevelImports extends Phase {
   /** 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.
+   *
+   *  Transformed imports of which selectors were all shadowed will be ignored in the future runs.
    */
   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 => {
+        val importedNames: List[Name] = (if selectors.exists(_.isWildcard) then
+          val allImportTypeMembers = expr.tpe.allMembers.map(_.name)
+          val renamedMembers = selectors.map(_.imported.name)
+          selectors.filter(_.isWildcard).map(_.rename) ++ allImportTypeMembers.filterNot(renamedMembers.contains)
+        else
+          selectors.map(_.rename)
+        )
+
+        val shadowedMembers = importedNames.intersect(definitionsAfterImport)
+        val adjustedSelectors = shadowedMembers.map(collidingMember => {
           untpd.ImportSelector(untpd.Ident(collidingMember), untpd.Ident(CollectTopLevelImports.nme.WILDCARD))
-        }).toList
+        })
 
-        val filteredSelectors = selectors.filterNot(importSelector => membersIntersection.contains(importSelector.imported.name))
+        val remainingSelectors = selectors.filterNot(importSelector => {
+            shadowedMembers.contains(importSelector.rename)
+        })
 
-        Import(expr, transformedSelectors.toList  ::: filteredSelectors)
-    }
+        if remainingSelectors.isEmpty then
+          None
+        else
+          Some(Import(expr, adjustedSelectors ++ remainingSelectors))
+    }.flatten
 
   private def collectTopLevelMemberDefs(trees: List[Tree])(using Context): List[(Name, Int)] =
     trees.collect {

compiler/test-resources/repl/import-shadowing

@@ -1,4 +1,4 @@
-scala> object A { def f = 1 }
+scala> object A { def f = 1; def t = 2 }
 // defined object A
 
 scala> object B { def f = 2 }
@@ -32,12 +32,12 @@ 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
+scala> def f = 6; println(f); import A._; println(f); // import shadowing should only work on toplevel definitions in the following runs
 6
 6
 def f: Int
 
-scala> import A._; println(f); def f = 7; println(f)
+scala> import A._; println(f); def f = 7; println(f)  // import shadowing should only work on toplevel definitions in the following runs
 7
 7
 def f: Int
@@ -53,3 +53,45 @@ def f: Int
 
 scala> val x6 = f
 val x6: Int = 9
+
+scala> import A.{f => ff}; def f = 10
+def f: Int
+
+scala> val x7 = f
+val x7: Int = 10
+
+scala> val x8 = ff
+val x8: Int = 1
+
+scala> def f = 10; import A.{f => ff}
+def f: Int
+
+scala> val x9 = f
+val x9: Int = 10
+
+scala> val x10 = ff
+val x10: Int = 1
+
+scala> import A.{t, _}; def f = 11
+def f: Int
+
+scala> val x11 = f
+val x11: Int = 11
+
+scala> def f = 12; import A.{t, _}
+def f: Int
+
+scala> val x12 = f
+val x12: Int = 1
+
+scala> def f = 13; import A.{t => f}
+def f: Int
+
+scala> val x13 = f
+val x13: Int = 2
+
+scala> import A.{t => f}; def f = 14
+def f: Int
+
+scala> val x14 = f
+val x14: Int = 14