IDE: Look for overrides in the whole project

When doing go-to-definition, we used to look for symbols that override
the symbol selected for go to definition only in the same source file as
the one that was selected. This commit changes that, as suggested in the
review of scala#5208.

Author: Duhemm

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

@@ -43,10 +43,7 @@ object Interactive {
     /** Include trees whose symbol is overridden by `sym` */
     val overridden: Set = Set(1 << 0)
 
-    /**
-     * Include trees whose symbol overrides `sym` (but for performance only in same source
-     * file)
-     */
+    /** Include trees whose symbol overrides `sym` */
     val overriding: Set = Set(1 << 1)
 
     /** Include references */
@@ -328,34 +325,45 @@ object Interactive {
     path.find(_.isInstanceOf[DefTree]).getOrElse(EmptyTree)
 
   /**
-   * Find the definitions of the symbol at the end of `path`.
+   * Find the definitions of the symbol at the end of `path`. In the case of an import node,
+   * all imported symbols will be considered.
    *
    * @param path   The path to the symbol for which we want the definitions.
    * @param driver The driver responsible for `path`.
    * @return The definitions for the symbol at the end of `path`.
    */
-  def findDefinitions(path: List[Tree], pos: SourcePosition, driver: InteractiveDriver)(implicit ctx: Context): List[SourceTree] = {
-    enclosingSourceSymbols(path, pos).flatMap { sym =>
-      val enclTree = enclosingTree(path)
-      val includeLocal = if (sym.exists && sym.isLocal) Include.local else Include.empty
-
-      val (trees, include) =
-        if (enclTree.isInstanceOf[MemberDef])
-          (driver.allTreesContaining(sym.name.sourceModuleName.toString),
-            Include.definitions | Include.overriding | Include.overridden)
-        else sym.topLevelClass match {
-          case cls: ClassSymbol =>
-            val trees = Option(cls.sourceFile).flatMap(InteractiveDriver.toUriOption) match {
-              case Some(uri) if driver.openedTrees.contains(uri) =>
-                driver.openedTrees(uri)
-              case _ => // Symbol comes from the classpath
-                SourceTree.fromSymbol(cls).toList
-            }
-            (trees, Include.definitions | Include.overriding)
-          case _ =>
-            (Nil, Include.empty)
-        }
+  def findDefinitions(path: List[Tree], pos: SourcePosition, driver: InteractiveDriver): List[SourceTree] = {
+    implicit val ctx = driver.currentCtx
+    val enclTree = enclosingTree(path)
+    val includeOverridden = enclTree.isInstanceOf[MemberDef]
+    val symbols = enclosingSourceSymbols(path, pos)
+    val includeExternal = symbols.exists(!_.isLocal)
+    findDefinitions(symbols, driver, includeOverridden, includeExternal)
+  }
 
+  /**
+   * Find the definitions of `symbols`.
+   *
+   * @param symbols           The list of symbols for which to find a definition.
+   * @param driver            The driver responsible for the given symbols.
+   * @param includeOverridden If true, also include the symbols overridden by any of `symbols`.
+   * @param includeExternal   If true, also look for definitions on the classpath.
+   * @return The definitions for the symbols in `symbols`, and if `includeOverridden` is set, the
+   *         definitions for the symbols that they override.
+   */
+  def findDefinitions(symbols: List[Symbol],
+                      driver: InteractiveDriver,
+                      includeOverridden: Boolean,
+                      includeExternal: Boolean): List[SourceTree] = {
+    implicit val ctx = driver.currentCtx
+    val include = Include.definitions | Include.overriding |
+      (if (includeOverridden) Include.overridden else Include.empty)
+    symbols.flatMap { sym =>
+      val name = sym.name.sourceModuleName.toString
+      val includeLocal = if (sym.exists && sym.isLocal) Include.local else Include.empty
+      val trees =
+        if (includeExternal) driver.allTreesContaining(name)
+        else driver.sourceTreesContaining(name)
       findTreesMatching(trees, include | includeLocal, sym)
     }
   }

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

@@ -289,10 +289,9 @@ class DottyLanguageServer extends LanguageServer
       /*isIncomplete = */ false, items.map(completionItem).asJava))
   }
 
-  /** If cursor is on a reference, show its definition and all overriding definitions in
-   *  the same source as the primary definition.
+  /** If cursor is on a reference, show its definition and all overriding definitions.
    *  If cursor is on a definition, show this definition together with all overridden
-   *  and overriding definitions (in all sources).
+   *  and overriding definitions.
    */
   override def definition(params: TextDocumentPositionParams) = computeAsync { cancelToken =>
     val uri = new URI(params.getTextDocument.getUri)

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

@@ -322,4 +322,26 @@ class DefinitionTest {
      .definition(m11 to m12, List(m3 to m4))
   }
 
+  @Test def definitionShowOverrides: Unit = {
+    withSources(
+      code"""class A { def ${m1}foo${m2}: Int = 0 }""",
+      code"""class B extends A { def ${m3}foo${m4}: Int = 1 }""",
+      code"""class C extends A { def ${m5}foo${m6}: Int = 2 }""",
+      code"""class D extends C { def ${m7}foo${m8}: Int = 3 }""",
+      code"""object O {
+               val a = new A().${m9}foo${m10}
+               val b = new B().${m11}foo${m12}
+               val c = new C().${m13}foo${m14}
+               val d = new D().${m15}foo${m16}
+             }"""
+    ).definition(m1 to m2, List(m1 to m2, m3 to m4, m5 to m6, m7 to m8))
+     .definition(m3 to m4, List(m1 to m2, m3 to m4))
+     .definition(m5 to m6, List(m1 to m2, m5 to m6, m7 to m8))
+     .definition(m7 to m8, List(m1 to m2, m5 to m6, m7 to m8))
+     .definition(m9 to m10, List(m1 to m2, m3 to m4, m5 to m6, m7 to m8))
+     .definition(m11 to m12, List(m3 to m4))
+     .definition(m13 to m14, List(m5 to m6, m7 to m8))
+     .definition(m15 to m16, List(m7 to m8))
+  }
+
 }