Address review comments

Author: Duhemm

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

@@ -54,10 +54,13 @@ object Interactive {
     path.dropWhile(!_.symbol.exists).headOption.getOrElse(tpd.EmptyTree)
 
   /**
-   * The source symbol that is the closest to `path`.
+   * The source symbols that are the closest to `path`.
    *
-   * @param path The path to the tree whose symbol to extract.
-   * @return The source symbol that is the closest to `path`.
+   * If this path ends in an import, then this returns all the symbols that are imported by this
+   * import statement.
+   *
+   * @param path The path to the tree whose symbols to extract.
+   * @return The source symbols that are the closest to `path`.
    *
    * @see sourceSymbol
    */
@@ -69,20 +72,20 @@ object Interactive {
         if (funSym.name == StdNames.nme.copy
           && funSym.is(Synthetic)
           && funSym.owner.is(CaseClass)) {
-            funSym.owner.info.member(name).symbol :: Nil
+            List(funSym.owner.info.member(name).symbol)
         } else {
           val classTree = funSym.topLevelClass.asClass.rootTree
           val paramSymbol =
             for {
               DefDef(_, _, paramss, _, _) <- tpd.defPath(funSym, classTree).lastOption
               param <- paramss.flatten.find(_.name == name)
             } yield param.symbol
-          paramSymbol.getOrElse(fn.symbol) :: Nil
+          List(paramSymbol.getOrElse(fn.symbol))
         }
 
       // For constructor calls, return the `<init>` that was selected
       case _ :: (_:  New) :: (select: Select) :: _ =>
-        select.symbol :: Nil
+        List(select.symbol)
 
       case (_: Thicket) :: (imp: Import) :: _ =>
         importedSymbols(imp, _.pos.contains(pos.pos))
@@ -91,7 +94,7 @@ object Interactive {
         importedSymbols(imp, _.pos.contains(pos.pos))
 
       case _ =>
-        enclosingTree(path).symbol :: Nil
+        List(enclosingTree(path).symbol)
     }
 
     syms.map(Interactive.sourceSymbol).filter(_.exists)
@@ -341,7 +344,7 @@ object Interactive {
                 val tree = tpd.Select(imp.expr, sym.name).withPos(name.pos)
                 val renameTree = rename.map { r =>
                   val name = if (sym.name.isTypeName) r.name.toTypeName else r.name
-                  RenameTree(name, tpd.Select(imp.expr, sym.name)).withPos(r.pos)
+                  tpd.Select(imp.expr, sym.name).withPos(r.pos)
                 }
                 renameTree.foreach(traverse)
                 traverse(tree)
@@ -547,20 +550,10 @@ object Interactive {
     */
    private def importedSymbols(expr: tpd.Tree, name: Name)(implicit ctx: Context): List[Symbol] = {
      def lookup(name: Name): Symbol = expr.tpe.member(name).symbol
-       lookup(name.toTermName) ::
-         lookup(name.toTypeName) ::
-         lookup(name.moduleClassName) ::
-         lookup(name.sourceModuleName) :: Nil
-   }
-
-  /**
-   * Used to represent a renaming import `{foo => bar}`.
-   * We need this because the name of the tree must be the new name, but the
-   * denotation must be that of the importee.
-   */
-   private case class RenameTree(name: Name, underlying: Tree) extends NameTree {
-     override def denot(implicit ctx: Context) = underlying.denot
-     myTpe = NoType
+       List(lookup(name.toTermName),
+            lookup(name.toTypeName),
+            lookup(name.moduleClassName),
+            lookup(name.sourceModuleName))
    }
 
   /**