Fix #3979: Completion for renamed imports

We introduce a new `RenameAwareScope` that tracks the name associated
with a symbol in the scope. Calling `toListWithNames` returns the list
of symbols in this scope along with the name that should be used to
refer to the symbol in this scope.

Fixes #3979

Author: Duhemm

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

@@ -156,15 +156,15 @@ object Interactive {
 
   /** Get possible completions from tree at `pos`
    *
-   *  @return offset and list of symbols for possible completions
+   *  @return offset and list of (symbol, name in scope) for possible completions
    */
-  def completions(pos: SourcePosition)(implicit ctx: Context): (Int, List[Symbol]) = {
+  def completions(pos: SourcePosition)(implicit ctx: Context): (Int, List[(Symbol, Name)]) = {
     val path = pathTo(ctx.compilationUnit.tpdTree, pos.pos)
     computeCompletions(pos, path)(contextOfPath(path))
   }
 
-  private def computeCompletions(pos: SourcePosition, path: List[Tree])(implicit ctx: Context): (Int, List[Symbol]) = {
-    val completions = Scopes.newScope.openForMutations
+  private def computeCompletions(pos: SourcePosition, path: List[Tree])(implicit ctx: Context): (Int, List[(Symbol, Name)]) = {
+    val completions = new RenameAwareScope
 
     val (completionPos, prefix, termOnly, typeOnly) = path match {
       case (ref: RefTree) :: _ =>
@@ -188,53 +188,53 @@ object Interactive {
      *  as completion results. However, if a user explicitly writes all '$' characters in an
      *  identifier, we should complete the rest.
      */
-    def include(sym: Symbol) =
-      sym.name.startsWith(prefix) &&
-      !sym.name.toString.drop(prefix.length).contains('$') &&
+    def include(sym: Symbol, nameInScope: Name) =
+      nameInScope.startsWith(prefix) &&
+      !nameInScope.toString.drop(prefix.length).contains('$') &&
       (!termOnly || sym.isTerm) &&
       (!typeOnly || sym.isType)
 
-    def enter(sym: Symbol) =
-      if (include(sym)) completions.enter(sym)
+    def enter(sym: Symbol, nameInScope: Name) =
+      if (include(sym, nameInScope)) completions.enter(sym, nameInScope)
 
     def add(sym: Symbol) =
-      if (sym.exists && !completions.lookup(sym.name).exists) enter(sym)
+      if (sym.exists && !completions.lookup(sym.name).exists) enter(sym, sym.name)
 
-    def addMember(site: Type, name: Name) =
-      if (!completions.lookup(name).exists)
-        for (alt <- site.member(name).alternatives) enter(alt.symbol)
+    def addMember(site: Type, name: Name, nameInScope: Name) =
+      if (!completions.lookup(nameInScope).exists)
+        for (alt <- site.member(name).alternatives) enter(alt.symbol, nameInScope)
 
     def accessibleMembers(site: Type, superAccess: Boolean = true): Seq[Symbol] = site match {
       case site: NamedType if site.symbol.is(Package) =>
-        site.decls.toList.filter(include) // Don't look inside package members -- it's too expensive.
+        site.decls.toList.filter(sym => include(sym, sym.name)) // Don't look inside package members -- it's too expensive.
       case _ =>
         def appendMemberSyms(name: Name, buf: mutable.Buffer[SingleDenotation]): Unit =
           try buf ++= site.member(name).alternatives
           catch { case ex: TypeError => }
         site.memberDenots(takeAllFilter, appendMemberSyms).collect {
-          case mbr if include(mbr.symbol) => mbr.accessibleFrom(site, superAccess).symbol
+          case mbr if include(mbr.symbol, mbr.symbol.name) => mbr.accessibleFrom(site, superAccess).symbol
           case _ => NoSymbol
         }.filter(_.exists)
     }
 
     def addAccessibleMembers(site: Type, superAccess: Boolean = true): Unit =
-      for (mbr <- accessibleMembers(site)) addMember(site, mbr.name)
+      for (mbr <- accessibleMembers(site)) addMember(site, mbr.name, mbr.name)
 
     def getImportCompletions(ictx: Context): Unit = {
       implicit val ctx = ictx
       val imp = ctx.importInfo
       if (imp != null) {
-        def addImport(name: TermName) = {
-          addMember(imp.site, name)
-          addMember(imp.site, name.toTypeName)
+        def addImport(original: TermName, nameInScope: TermName) = {
+          addMember(imp.site, original, nameInScope)
+          addMember(imp.site, original.toTypeName, nameInScope.toTypeName)
+        }
+        imp.reverseMapping.foreachBinding { (nameInScope, original) =>
+          if (original != nameInScope || !imp.excluded.contains(original))
+            addImport(original, nameInScope)
         }
-        // FIXME: We need to also take renamed items into account for completions,
-        // That means we have to return list of a pairs (Name, Symbol) instead of a list
-        // of symbols from `completions`.!=
-        for (imported <- imp.originals if !imp.excluded.contains(imported)) addImport(imported)
         if (imp.isWildcardImport)
           for (mbr <- accessibleMembers(imp.site) if !imp.excluded.contains(mbr.name.toTermName))
-            addMember(imp.site, mbr.name)
+            addMember(imp.site, mbr.name, mbr.name)
       }
     }
 
@@ -279,7 +279,7 @@ object Interactive {
       case _  => getScopeCompletions(ctx)
     }
 
-    val completionList = completions.toList
+    val completionList = completions.toListWithNames
     interactiv.println(i"completion with pos = $pos, prefix = $prefix, termOnly = $termOnly, typeOnly = $typeOnly = $completionList%, %")
     (completionPos, completionList)
   }
@@ -293,7 +293,7 @@ object Interactive {
         def addMember(name: Name, buf: mutable.Buffer[SingleDenotation]): Unit =
           buf ++= prefix.member(name).altsWith(sym =>
             !exclude(sym) && sym.isAccessibleFrom(prefix)(boundaryCtx))
-          prefix.memberDenots(completionsFilter, addMember).map(_.symbol).toList
+        prefix.memberDenots(completionsFilter, addMember).map(_.symbol).toList
       }
       else Nil
     }
@@ -572,4 +572,23 @@ object Interactive {
     n0.stripModuleClassSuffix.toTermName eq n1.stripModuleClassSuffix.toTermName
   }
 
+  /** A scope that tracks renames of the entered symbols.
+   *  Useful for providing completions for renamed symbols
+   *  in the REPL and the IDE.
+   */
+  private class RenameAwareScope extends Scopes.MutableScope {
+    private[this] val renames: mutable.Map[Symbol, Name] = mutable.Map.empty
+
+    /** Enter the symbol `sym` in this scope, recording a potential renaming. */
+    def enter[T <: Symbol](sym: T, name: Name)(implicit ctx: Context): T = {
+      if (name != sym.name) renames += sym -> name
+      newScopeEntry(name, sym)
+      sym
+    }
+
+    /** Lists the symbols in this scope along with the name associated with them. */
+    def toListWithNames(implicit ctx: Context): List[(Symbol, Name)] =
+      toList.map(sym => (sym, renames.get(sym).getOrElse(sym.name)))
+  }
+
 }

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

@@ -149,8 +149,8 @@ class ReplDriver(settings: Array[String],
 
   /** Extract possible completions at the index of `cursor` in `expr` */
   protected[this] final def completions(cursor: Int, expr: String, state0: State): List[Candidate] = {
-    def makeCandidate(completion: Symbol)(implicit ctx: Context) = {
-      val displ = completion.name.toString
+    def makeCandidate(name: Name)(implicit ctx: Context) = {
+      val displ = name.toString
       new Candidate(
         /* value    = */ displ,
         /* displ    = */ displ, // displayed value
@@ -171,7 +171,7 @@ class ReplDriver(settings: Array[String],
         implicit val ctx = state.context.fresh.setCompilationUnit(unit)
         val srcPos = SourcePosition(file, Position(cursor))
         val (_, completions) = Interactive.completions(srcPos)
-        completions.map(makeCandidate)
+        completions.map(c => makeCandidate(c._2))
       }
       .getOrElse(Nil)
   }

compiler/test/dotty/tools/repl/TabcompleteTests.scala

@@ -80,4 +80,14 @@ class TabcompleteTests extends ReplTest {
       val expected = List("FileDescriptor")
       assertEquals(expected, tabComplete("val foo: FileDesc"))
     }
+
+  @Test def tabCompleteRenamedImport =
+    fromInitialState { implicit state =>
+      val src = "import java.io.{FileDescriptor => Renamed}"
+      run(src)
+    }
+    .andThen { implicit state =>
+      val expected = List("Renamed")
+      assertEquals(expected, tabComplete("val foo: Rena"))
+    }
 }

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

@@ -285,7 +285,7 @@ class DottyLanguageServer extends LanguageServer
     }
 
     JEither.forRight(new CompletionList(
-      /*isIncomplete = */ false, items.map(completionItem).asJava))
+      /*isIncomplete = */ false, items.map(completionItem.tupled).asJava))
   }
 
   /** If cursor is on a reference, show its definition and all overriding definitions in
@@ -774,7 +774,7 @@ object DottyLanguageServer {
   }
 
   /** Create an lsp4j.CompletionItem from a Symbol */
-  def completionItem(sym: Symbol)(implicit ctx: Context): lsp4j.CompletionItem = {
+  def completionItem(sym: Symbol, name: Name)(implicit ctx: Context): lsp4j.CompletionItem = {
     def completionItemKind(sym: Symbol)(implicit ctx: Context): lsp4j.CompletionItemKind = {
       import lsp4j.{CompletionItemKind => CIK}
 
@@ -792,7 +792,7 @@ object DottyLanguageServer {
         CIK.Field
     }
 
-    val label = sym.name.show
+    val label = name.show
     val item = new lsp4j.CompletionItem(label)
     item.setDetail(sym.info.widenTermRefExpr.show)
     item.setKind(completionItemKind(sym))

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

@@ -19,4 +19,25 @@ class CompletionTest {
       code"object Main { import Foo._; val bar: Bar = new Bar; bar.b${m1} }"
     ) .completion(m1, Set(("baz", CompletionItemKind.Method, "=> Int")))
   }
+
+  @Test def completionOnImport: Unit = {
+    code"""import java.io.FileDescriptor
+           trait Foo { val x: FileDesc$m1 }""".withSource
+      .completion(m1, Set(("FileDescriptor", CompletionItemKind.Class, "Object{...}")))
+  }
+
+  @Test def completionOnRenamedImport: Unit = {
+    code"""import java.io.{FileDescriptor => AwesomeStuff}
+           trait Foo { val x: Awesom$m1 }""".withSource
+      .completion(m1, Set(("AwesomeStuff", CompletionItemKind.Class, "Object{...}")))
+  }
+
+  @Test def completionOnRenamedImport2: Unit = {
+    code"""import java.util.{HashMap => MyImportedSymbol}
+           trait Foo {
+             import java.io.{FileDescriptor => MyImportedSymbol}
+             val x: MyImp$m1
+           }""".withSource
+      .completion(m1, Set(("MyImportedSymbol", CompletionItemKind.Class, "Object{...}")))
+  }
 }