Move helpers for handling imports to tpd.scala

Author: Duhemm

compiler/src/dotty/tools/dotc/ast/tpd.scala

@@ -1147,5 +1147,65 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     case _ =>
       EmptyTree
   }
+
+  /**
+   * The symbols that are imported with `expr.name`
+   *
+   * @param expr The base of the import statement
+   * @param name The name that is being imported.
+   * @return All the symbols that would be imported with `expr.name`.
+   */
+  def importedSymbols(expr: Tree, name: Name)(implicit ctx: Context): List[Symbol] = {
+    def lookup(name: Name): Symbol = expr.tpe.member(name).symbol
+    List(lookup(name.toTermName),
+         lookup(name.toTypeName),
+         lookup(name.moduleClassName),
+         lookup(name.sourceModuleName))
+  }
+
+  /**
+   * All the symbols that are imported by the first selector of `imp` that matches
+   * `selectorPredicate`.
+   *
+   * @param imp The import statement to analyze
+   * @param selectorPredicate A test to find the selector to use.
+   * @return The symbols imported.
+   */
+  def importedSymbols(imp: Import,
+                      selectorPredicate: untpd.Tree => Boolean = util.common.alwaysTrue)
+                     (implicit ctx: Context): List[Symbol] = {
+    val symbols = imp.selectors.find(selectorPredicate) match {
+      case Some(id: untpd.Ident) =>
+        importedSymbols(imp.expr, id.name)
+      case Some(Thicket((id: untpd.Ident) :: (_: untpd.Ident) :: Nil)) =>
+        importedSymbols(imp.expr, id.name)
+      case _ =>
+        Nil
+    }
+
+    symbols.map(_.sourceSymbol).filter(_.exists).distinct
+  }
+
+  def importSelections(imp: Import)(implicit ctx: Context): List[Select] = {
+    val imported =
+      imp.selectors.flatMap {
+        case id: untpd.Ident =>
+          importedSymbols(imp.expr, id.name).map((_, id, None))
+        case Thicket((id: untpd.Ident) :: (newName: untpd.Ident) :: Nil) =>
+          val renaming = Some(newName)
+          importedSymbols(imp.expr, id.name).map((_, id, renaming))
+      }
+    imported.flatMap { case (symbol, name, rename) =>
+      val tree = Select(imp.expr, symbol.name).withPos(name.pos)
+      val renameTree = rename.map { r =>
+        // Get the type of the symbol that is actually selected, and construct a select
+        // node with the new name and the type of the real symbol.
+        val name = if (symbol.name.isTypeName) r.name.toTypeName else r.name
+        val actual = Select(imp.expr, symbol.name)
+        Select(imp.expr, name).withPos(r.pos).withType(actual.tpe)
+      }
+      tree :: renameTree.toList
+    }
+  }
 }
 

compiler/src/dotty/tools/dotc/core/Symbols.scala

@@ -624,6 +624,26 @@ object Symbols {
       }
     }
 
+    /** A symbol related to `sym` that is defined in source code.
+     *
+     *  @see enclosingSourceSymbols
+     */
+    @annotation.tailrec final def sourceSymbol(implicit ctx: Context): Symbol =
+      if (!denot.exists)
+        this
+      else if (denot.is(ModuleVal))
+        this.moduleClass.sourceSymbol // The module val always has a zero-extent position
+      else if (denot.is(Synthetic)) {
+        val linked = denot.linkedClass
+        if (linked.exists && !linked.is(Synthetic))
+          linked
+        else
+          denot.owner.sourceSymbol
+      }
+      else if (denot.isPrimaryConstructor)
+        denot.owner.sourceSymbol
+      else this
+
     /** The position of this symbol, or NoPosition if the symbol was not loaded
      *  from source or from TASTY. This is always a zero-extent position.
      *

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

@@ -97,29 +97,9 @@ object Interactive {
         List(enclosingTree(path).symbol)
     }
 
-    syms.map(Interactive.sourceSymbol).filter(_.exists)
+    syms.map(_.sourceSymbol).filter(_.exists)
   }
 
-  /** A symbol related to `sym` that is defined in source code.
-   *
-   *  @see enclosingSourceSymbols
-   */
-  @tailrec def sourceSymbol(sym: Symbol)(implicit ctx: Context): Symbol =
-    if (!sym.exists)
-      sym
-    else if (sym.is(ModuleVal))
-      sourceSymbol(sym.moduleClass) // The module val always has a zero-extent position
-    else if (sym.is(Synthetic)) {
-      val linked = sym.linkedClass
-      if (linked.exists && !linked.is(Synthetic))
-        linked
-      else
-        sourceSymbol(sym.owner)
-    }
-    else if (sym.isPrimaryConstructor)
-      sourceSymbol(sym.owner)
-    else sym
-
   /** Check if `tree` matches `sym`.
    *  This is the case if the symbol defined by `tree` equals `sym`,
    *  or the source symbol of tree equals sym,
@@ -132,7 +112,7 @@ object Interactive {
       sym1.owner.derivesFrom(sym2.owner) && sym1.overriddenSymbol(sym2.owner.asClass) == sym2
 
     (  sym == tree.symbol
-    || sym.exists && sym == sourceSymbol(tree.symbol)
+    || sym.exists && sym == tree.symbol.sourceSymbol
     || include != 0 && sym.name == tree.symbol.name && sym.maybeOwner != tree.symbol.maybeOwner
        && (  (include & Include.overridden) != 0 && overrides(sym, tree.symbol)
           || (include & Include.overriding) != 0 && overrides(tree.symbol, sym)
@@ -327,37 +307,12 @@ object Interactive {
 
     def traverser(source: SourceFile) = {
       new untpd.TreeTraverser {
-        private def handleImport(imp: tpd.Import): Unit = {
-          val imported =
-            imp.selectors.flatMap {
-              case id: untpd.Ident =>
-                importedSymbols(imp.expr, id.name).map((_, id, None))
-              case Thicket((id: untpd.Ident) :: (newName: untpd.Ident) :: Nil) =>
-                val renaming = if (includeRenamingImports) Some(newName) else None
-                importedSymbols(imp.expr, id.name).map((_, id, renaming))
-            }
-          imported match {
-            case Nil =>
-              traverse(imp.expr)
-            case syms =>
-              syms.foreach { case (sym, name, rename) =>
-                val tree = tpd.Select(imp.expr, sym.name).withPos(name.pos)
-                val renameTree = rename.map { r =>
-                  // Get the type of the symbol that is actually selected, and construct a select
-                  // node with the new name and the type of the real symbol.
-                  val name = if (sym.name.isTypeName) r.name.toTypeName else r.name
-                  val actual = tpd.Select(imp.expr, sym.name)
-                  tpd.Select(imp.expr, name).withPos(r.pos).withType(actual.tpe)
-                }
-                renameTree.foreach(traverse)
-                traverse(tree)
-              }
-          }
-        }
         override def traverse(tree: untpd.Tree)(implicit ctx: Context) = {
           tree match {
-            case imp: untpd.Import if includeImports =>
-              handleImport(imp.asInstanceOf[tpd.Import])
+            case imp: untpd.Import if includeImports && tree.hasType =>
+              val tree = imp.asInstanceOf[tpd.Import]
+              val selections = tpd.importSelections(tree)
+              selections.foreach(traverse)
             case utree: untpd.NameTree if tree.hasType =>
               val tree = utree.asInstanceOf[tpd.NameTree]
               if (tree.symbol.exists
@@ -572,44 +527,6 @@ object Interactive {
     }
   }
 
-  /**
-   * All the symbols that are imported by import statement `imp`, if it matches
-   * the predicate `selectorPredicate`.
-   *
-   * @param imp The import statement to analyze
-   * @param selectorPredicate A test to find the selector to use.
-   * @return The symbols imported.
-   */
-   private def importedSymbols(imp: tpd.Import,
-                       selectorPredicate: untpd.Tree => Boolean = util.common.alwaysTrue)
-                      (implicit ctx: Context): List[Symbol] = {
-     val symbols = imp.selectors.find(selectorPredicate) match {
-       case Some(id: untpd.Ident) =>
-         importedSymbols(imp.expr, id.name)
-       case Some(Thicket((id: untpd.Ident) :: (_: untpd.Ident) :: Nil)) =>
-         importedSymbols(imp.expr, id.name)
-       case _ =>
-         Nil
-     }
-
-     symbols.map(sourceSymbol).filter(_.exists).distinct
-   }
-
-   /**
-    * The symbols that are imported with `expr.name`
-    *
-    * @param expr The base of the import statement
-    * @param name The name that is being imported.
-    * @return All the symbols that would be imported with `expr.name`.
-    */
-   private def importedSymbols(expr: tpd.Tree, name: Name)(implicit ctx: Context): List[Symbol] = {
-     def lookup(name: Name): Symbol = expr.tpe.member(name).symbol
-       List(lookup(name.toTermName),
-            lookup(name.toTypeName),
-            lookup(name.moduleClassName),
-            lookup(name.sourceModuleName))
-   }
-
   /**
    * Is this tree using a renaming introduced by an import statement?
    *

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

@@ -417,11 +417,14 @@ class DottyLanguageServer extends LanguageServer
 
     if (tp.isError || tpw == NoType) null // null here indicates that no response should be sent
     else {
-      val symbol = Interactive.enclosingSourceSymbols(path, pos).headOption.orNull
-      if (symbol == null) return null
-      val docComment = ParsedComment.docOf(symbol)
-      val content = hoverContent(Some(tpw.show), docComment)
-      new Hover(content, null)
+      Interactive.enclosingSourceSymbols(path, pos) match {
+        case Nil =>
+          null
+        case symbol :: _ =>
+          val docComment = ParsedComment.docOf(symbol)
+          val content = hoverContent(Some(tpw.show), docComment)
+          new Hover(content, null)
+      }
     }
   }