IDE: Support imports when renaming

Author: Duhemm

compiler/src/dotty/tools/dotc/interactive/Interactive.scala

@@ -29,6 +29,7 @@ object Interactive {
     val definitions: Int = 8 // include definitions
     val linkedClass: Int = 16 // include `symbol.linkedClass`
     val imports: Int = 32 // include imports in the results
+    val renamingImports: Int = 64 // Include renamed symbols and renaming part of imports in the results
   }
 
   /** Does this tree define a symbol ? */
@@ -318,6 +319,7 @@ object Interactive {
     (implicit ctx: Context): List[SourceNamedTree] = safely {
     val includeReferences = (include & Include.references) != 0
     val includeImports = (include & Include.imports) != 0
+    val includeRenamingImports = (include & Include.renamingImports) != 0
     val buf = new mutable.ListBuffer[SourceNamedTree]
 
     def traverser(source: SourceFile) = {
@@ -328,7 +330,8 @@ object Interactive {
               case id: untpd.Ident =>
                 importedSymbols(imp.expr, id.name).map((_, id, None))
               case Thicket((id: untpd.Ident) :: (newName: untpd.Ident) :: Nil) =>
-                importedSymbols(imp.expr, id.name).map((_, id, Some(newName)))
+                val renaming = if (includeRenamingImports) Some(newName) else None
+                importedSymbols(imp.expr, id.name).map((_, id, renaming))
             }
           imported match {
             case Nil =>
@@ -386,9 +389,11 @@ object Interactive {
     val linkedSym = symbol.linkedClass
     val includeDeclaration = (includes & Include.definitions) != 0
     val includeLinkedClass = (includes & Include.linkedClass) != 0
+    val includeRenamingImports = (includes & Include.renamingImports) != 0
     val predicate: NameTree => Boolean = tree =>
       (  !tree.symbol.isPrimaryConstructor
       && (includeDeclaration || !Interactive.isDefinition(tree))
+      && (includeRenamingImports || !isRenamed(tree))
       && (  Interactive.matchSymbol(tree, symbol, includes)
          || (  includeDeclaration
             && includeLinkedClass
@@ -558,4 +563,17 @@ object Interactive {
      myTpe = NoType
    }
 
+  /**
+   * Is this tree using a renaming introduced by an import statement?
+   *
+   * @param tree The tree to inspect
+   * @return True, if this tree's name is different than its symbol's name, indicating that
+   *         it uses a renaming introduced by an import statement.
+   */
+  private def isRenamed(tree: NameTree)(implicit ctx: Context): Boolean = {
+    val symbol = tree.symbol
+    symbol.exists &&
+      tree.name.stripModuleClassSuffix != symbol.name.stripModuleClassSuffix
+  }
+
 }

language-server/src/dotty/tools/languageserver/DottyLanguageServer.scala

@@ -293,7 +293,8 @@ class DottyLanguageServer extends LanguageServer
       val trees = driver.allTreesContaining(sym.name.sourceModuleName.toString)
       val includeDeclaration = params.getContext.isIncludeDeclaration
       val includes =
-        Include.references | Include.overriding | Include.imports | (if (includeDeclaration) Include.definitions else 0)
+        Include.references | Include.overriding | Include.imports | Include.renamingImports |
+          (if (includeDeclaration) Include.definitions else 0)
       val refs = Interactive.findTreesMatching(trees, includes, sym)
 
       refs.flatMap(ref => location(ref.namePos, positionMapperFor(ref.source)))
@@ -311,7 +312,7 @@ class DottyLanguageServer extends LanguageServer
     val syms = Interactive.enclosingSourceSymbols(path, pos)
     val newName = params.getNewName
     val includes =
-      Include.references | Include.definitions | Include.linkedClass | Include.overriding
+      Include.references | Include.definitions | Include.linkedClass | Include.overriding | Include.imports
 
     val refs = syms.flatMap { sym =>
       val trees = driver.allTreesContaining(sym.name.sourceModuleName.toString)
@@ -322,7 +323,7 @@ class DottyLanguageServer extends LanguageServer
       refs.groupBy(ref => toUri(ref.source).toString)
         .mapValues(refs =>
           refs.flatMap(ref =>
-            range(ref.namePos, positionMapperFor(ref.source)).map(nameRange => new TextEdit(nameRange, newName))).asJava)
+            range(ref.namePos, positionMapperFor(ref.source)).map(nameRange => new TextEdit(nameRange, newName))).distinct.asJava)
 
     new WorkspaceEdit(changes.asJava)
   }
@@ -336,7 +337,7 @@ class DottyLanguageServer extends LanguageServer
     val uriTrees = driver.openedTrees(uri)
     val path = Interactive.pathTo(uriTrees, pos)
     val syms = Interactive.enclosingSourceSymbols(path, pos)
-    val includes = Include.definitions | Include.references | Include.imports
+    val includes = Include.definitions | Include.references | Include.imports | Include.renamingImports
 
     syms.flatMap { sym =>
       val refs = Interactive.findTreesMatching(uriTrees, includes, sym)

language-server/test/dotty/tools/languageserver/RenameTest.scala

@@ -70,6 +70,38 @@ class RenameTest {
 
     testRenameFrom(m1)
     testRenameFrom(m2)
+    testRenameFrom(m3)
+    testRenameFrom(m4)
+  }
+
+  @Test def renameImport: Unit = {
+    def testRenameFrom(m: CodeMarker) =
+      withSources(
+        code"""object A { class ${m1}C${m2} }""",
+        code"""import A.${m3}C${m4}
+               object B"""
+      ).rename(m, "NewName", Set(m1 to m2, m3 to m4))
+
+    testRenameFrom(m1)
+    testRenameFrom(m2)
+    testRenameFrom(m3)
+    testRenameFrom(m4)
+  }
+
+  @Test def renameRenamedImport: Unit = {
+    def testRenameFrom(m: CodeMarker) =
+      withSources(
+        code"""object A { class ${m1}C${m2} }""",
+        code"""import A.{${m3}C${m4} => D}
+        object B { new ${m5}D${m6} }"""
+      ).rename(m, "NewName", Set(m1 to m2, m3 to m4))
+
+    testRenameFrom(m1)
+    testRenameFrom(m2)
+    testRenameFrom(m3)
+    testRenameFrom(m4)
+    testRenameFrom(m5)
+    testRenameFrom(m6)
   }
 
 }