Remove Include.renamingImport

Author: Duhemm

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

@@ -29,7 +29,6 @@ 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 ? */
@@ -302,7 +301,6 @@ 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) = {
@@ -340,30 +338,31 @@ object Interactive {
   /**
    * Find trees that match `symbol` in `trees`.
    *
-   * @param trees    The trees to inspect.
-   * @param includes Whether to include references, definitions, etc.
-   * @param symbol   The symbol for which we want to find references.
+   * @param trees     The trees to inspect.
+   * @param includes  Whether to include references, definitions, etc.
+   * @param symbol    The symbol for which we want to find references.
+   * @param predicate An additional predicate that the trees must match.
    */
   def findTreesMatching(trees: List[SourceTree],
                         includes: Include.Set,
-                        symbol: Symbol)(implicit ctx: Context): List[SourceNamedTree] = {
+                        symbol: Symbol,
+                        predicate: NameTree => Boolean = util.common.alwaysTrue
+                       )(implicit ctx: Context): List[SourceNamedTree] = {
     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 =>
+    val fullPredicate: NameTree => Boolean = tree =>
       (  !tree.symbol.isPrimaryConstructor
       && (includeDeclaration || !Interactive.isDefinition(tree))
-      && (includeRenamingImports || !isRenamed(tree))
       && (  Interactive.matchSymbol(tree, symbol, includes)
-         || (  includeDeclaration
-            && includeLinkedClass
+         || ( includeLinkedClass
             && linkedSym.exists
             && Interactive.matchSymbol(tree, linkedSym, includes)
             )
          )
+      && predicate(tree)
       )
-    namedTrees(trees, includes, predicate)
+    namedTrees(trees, includes, fullPredicate)
   }
 
   /** The reverse path to the node that closest encloses position `pos`,
@@ -577,35 +576,4 @@ object Interactive {
     }
   }
 
-  /**
-   * In `enclosing`, find all the references to any of `syms` that have been renamed to `toName`.
-   *
-   * If `enclosing` is empty, it means the renaming import was top-level and the whole source file
-   * should be considered. Otherwise, we can restrict the search to this tree because renaming
-   * imports are local.
-   *
-   * @param toName    The name that is set by the renaming.
-   * @param enclosing The tree that encloses the renaming import, if it exists.
-   * @param syms      The symbols to which we want to find renamed references.
-   * @param allTrees  All the trees in this source file, in case we can't find `enclosing`.
-   * @param source    The sourcefile that where to look for references.
-   * @return All the references to the symbol under the cursor that are using `toName`.
-   */
-  def findTreesMatchingRenaming(toName: Name,
-                                syms: List[Symbol],
-                                trees: List[SourceTree]
-                               )(implicit ctx: Context): List[SourceNamedTree] = {
-
-    val includes =
-      Include.references | Include.imports | Include.renamingImports
-
-    syms.flatMap { sym =>
-      Interactive.namedTrees(trees,
-        includes,
-        tree =>
-          Interactive.sameName(tree.name, toName) &&
-          (Interactive.matchSymbol(tree, sym, includes) || Interactive.matchSymbol(tree, sym.linkedClass, includes)))
-    }
-  }
-
 }

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

@@ -311,8 +311,7 @@ class DottyLanguageServer extends LanguageServer
 
     val includes = {
       val includeDeclaration = params.getContext.isIncludeDeclaration
-      Include.references | Include.overriding | Include.imports | Include.renamingImports |
-        (if (includeDeclaration) Include.definitions else 0)
+      Include.references | Include.overriding | Include.imports | (if (includeDeclaration) Include.definitions else 0)
     }
 
     val uriTrees = driver.openedTrees(uri)
@@ -360,19 +359,25 @@ class DottyLanguageServer extends LanguageServer
       path match {
         // Selected a renaming in an import node
         case Thicket(_ :: (rename: Ident) :: Nil) :: (_: Import) :: rest if rename.pos.contains(pos.pos) =>
-          Interactive.findTreesMatchingRenaming(rename.name, syms, uriTrees)
+          val includes = Include.references | Include.linkedClass | Include.imports
+          syms.flatMap { sym =>
+            Interactive.findTreesMatching(uriTrees, includes, sym, t => Interactive.sameName(t.name, rename.name))
+          }
 
         // Selected a reference that has been renamed
         case (nameTree: NameTree) :: rest if Interactive.isRenamed(nameTree) =>
-          Interactive.findTreesMatchingRenaming(nameTree.name, syms, uriTrees)
+          val includes = Include.references | Include.linkedClass | Include.imports
+          syms.flatMap { sym =>
+            Interactive.findTreesMatching(uriTrees, includes, sym, t => Interactive.sameName(t.name, nameTree.name))
+          }
 
         case _ =>
           val includes =
             Include.references | Include.definitions | Include.linkedClass | Include.overriding | Include.imports
 
           syms.flatMap { sym =>
             val trees = driver.allTreesContaining(sym.name.sourceModuleName.toString)
-            Interactive.findTreesMatching(trees, includes, sym)
+            Interactive.findTreesMatching(trees, includes, sym, t => Interactive.sameName(t.name, sym.name))
           }
       }
 
@@ -395,7 +400,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 | Include.renamingImports
+    val includes = Include.definitions | Include.references | Include.imports
 
     syms.flatMap { sym =>
       val refs = Interactive.findTreesMatching(uriTrees, includes, sym)