Support jump to definition in top-level imports

This is done by recording the top level imports that appear in every
source file.

Author: Duhemm

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

@@ -280,7 +280,7 @@ object Interactive {
     (implicit ctx: Context): List[SourceTree] = safely {
     val buf = new mutable.ListBuffer[SourceTree]
 
-    trees foreach { case SourceTree(topTree, source) =>
+    trees foreach { case SourceTree(_, topTree, source) =>
       new untpd.TreeTraverser {
         override def traverse(tree: untpd.Tree)(implicit ctx: Context) = {
           tree match {
@@ -292,7 +292,7 @@ object Interactive {
                    && !tree.pos.isZeroExtent
                    && (includeReferences || isDefinition(tree))
                    && treePredicate(tree))
-                buf += SourceTree(tree, source)
+                buf += SourceTree(Nil, tree, source)
               traverseChildren(tree)
             case tree: untpd.Inlined =>
               traverse(tree.call)
@@ -339,11 +339,13 @@ object Interactive {
    *  or `Nil` if no such path exists. If a non-empty path is returned it starts with
    *  the tree closest enclosing `pos` and ends with an element of `trees`.
    */
-  def pathTo(trees: List[SourceTree], pos: SourcePosition)(implicit ctx: Context): List[Tree] =
-    trees.find(_.pos.contains(pos)) match {
-      case Some(tree) => pathTo(tree.tree, pos.pos)
+  def pathTo(trees: List[SourceTree], pos: SourcePosition)(implicit ctx: Context): List[Tree] = {
+    val allTrees = trees.flatMap(t => t.tree :: t.topLevelImports)
+    allTrees.find(t => t.pos.contains(pos.pos)) match {
+      case Some(tree) => pathTo(tree, pos.pos)
       case None => Nil
     }
+  }
 
   def pathTo(tree: Tree, pos: Position)(implicit ctx: Context): List[Tree] =
     if (tree.pos.contains(pos))

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

@@ -172,14 +172,15 @@ class InteractiveDriver(val settings: List[String]) extends Driver {
   private def topLevelClassTrees(topTree: Tree, source: SourceFile): List[SourceTree] = {
     val trees = new mutable.ListBuffer[SourceTree]
 
-    def addTrees(tree: Tree): Unit = tree match {
+    def addTrees(topLevelImports: List[Import], tree: Tree): Unit = tree match {
       case PackageDef(_, stats) =>
-        stats.foreach(addTrees)
+        val imports = stats.collect { case imp: Import => imp }
+        stats.foreach(addTrees(imports, _))
       case tree: TypeDef =>
-        trees += SourceTree(tree, source)
+        trees += SourceTree(topLevelImports, tree, source)
       case _ =>
     }
-    addTrees(topTree)
+    addTrees(Nil, topTree)
 
     trees.toList
   }

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

@@ -10,7 +10,7 @@ import Contexts._, NameOps._, Symbols._, StdNames._
 import util._, util.Positions._
 
 /** A typechecked named `tree` coming from `source` */
-case class SourceTree(tree: tpd.NameTree, source: SourceFile) {
+case class SourceTree(topLevelImports: List[tpd.Import], tree: tpd.NameTree, source: SourceFile) {
   /** The position of `tree` */
   def pos(implicit ctx: Context): SourcePosition = source.atPos(tree.pos)
 
@@ -47,10 +47,11 @@ object SourceTree {
       import ast.Trees._
       def sourceTreeOfClass(tree: tpd.Tree): Option[SourceTree] = tree match {
         case PackageDef(_, stats) =>
-          stats.flatMap(sourceTreeOfClass).headOption
+          val imports = stats.collect { case imp: tpd.Import => imp }
+          stats.flatMap(sourceTreeOfClass(_).map(_.copy(topLevelImports = imports))).headOption
         case tree: tpd.TypeDef if tree.symbol == sym =>
           val sourceFile = new SourceFile(sym.sourceFile, Codec.UTF8)
-          Some(SourceTree(tree, sourceFile))
+          Some(SourceTree(Nil, tree, sourceFile))
         case _ => None
       }
       sourceTreeOfClass(sym.treeContaining(id))