Add navigation to overridden symbols

These are now shown in "definitions" if the cursor position
is on a definition.

Author: odersky

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

@@ -18,6 +18,13 @@ import NameKinds.SimpleNameKind
 object Interactive {
   import ast.tpd._
 
+  object Include { // should be an enum, really.
+    type Set = Int
+    val overridden = 1 // include trees whose symbol is overridden by `sym`
+    val overriding = 2 // include trees whose symbol overrides `sym`
+    val references = 4 // include references and not just definitions
+  }
+
   /** Does this tree define a symbol ? */
   def isDefinition(tree: Tree) =
     tree.isInstanceOf[DefTree with NameTree]
@@ -28,19 +35,17 @@ object Interactive {
     if (path.isEmpty) NoType
     else path.head.tpe
   }
+  /** The closest enclosing tree with a symbol containing position `pos`.
+   */
+  def enclosingTree(trees: List[SourceTree], pos: SourcePosition)(implicit ctx: Context): Tree =
+    pathTo(trees, pos).dropWhile(!_.symbol.exists).headOption.getOrElse(tpd.EmptyTree)
 
   /** The source symbol of the closest enclosing tree with a symbol containing position `pos`.
    *
    *  @see sourceSymbol
    */
-  def enclosingSourceSymbol(trees: List[SourceTree], pos: SourcePosition)(implicit ctx: Context): Symbol = {
-    pathTo(trees, pos).dropWhile(!_.symbol.exists).headOption match {
-      case Some(tree) =>
-        sourceSymbol(tree.symbol)
-      case None =>
-        NoSymbol
-    }
-  }
+  def enclosingSourceSymbol(trees: List[SourceTree], pos: SourcePosition)(implicit ctx: Context): Symbol =
+    sourceSymbol(enclosingTree(trees, pos).symbol)
 
   /** A symbol related to `sym` that is defined in source code.
    *
@@ -65,14 +70,22 @@ object Interactive {
   /** 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,
-   *  or `includeOverridden is true, and `sym` is overriden by `tree`.
+   *  or `include` is `overridden`, and `tree` is overridden by `sym`,
+   *  or `include` is `overriding`, and `tree` overrides `sym`.
    */
-  def matchSymbol(tree: Tree, sym: Symbol, includeOverridden: Boolean)(implicit ctx: Context): Boolean =
+  def matchSymbol(tree: Tree, sym: Symbol, include: Include.Set)(implicit ctx: Context): Boolean = {
+
+    def overrides(sym1: Symbol, sym2: Symbol) =
+      sym1.owner.derivesFrom(sym2.owner) && sym1.overriddenSymbol(sym2.owner.asClass) == sym2
+
     (  sym == tree.symbol
     || sym.exists && sym == sourceSymbol(tree.symbol)
-    || includeOverridden && sym.name == tree.symbol.name &&
-       tree.symbol.owner.derivesFrom(sym.owner) && tree.symbol.overriddenSymbol(sym.owner.asClass) == sym
+    || include != 0 && sym.name == tree.symbol.name && sym.owner != tree.symbol.owner
+       && (  (include & Include.overridden) != 0 && overrides(sym, tree.symbol)
+          || (include & Include.overriding) != 0 && overrides(tree.symbol, sym)
+          )
     )
+  }
 
   private def safely[T](op: => List[T]): List[T] =
     try op catch { case ex: TypeError => Nil }
@@ -135,16 +148,13 @@ object Interactive {
    *  Note that nothing will be found for symbols not defined in source code,
    *  use `sourceSymbol` to get a symbol related to `sym` that is defined in
    *  source code.
-   *
-   *  @param includeReferences  If true, include references and not just definitions
-   *  @param includeOverridden  If true, include trees whose symbol is overriden by `sym`
    */
-  def namedTrees(trees: List[SourceTree], includeReferences: Boolean, includeOverridden: Boolean, sym: Symbol)
+  def namedTrees(trees: List[SourceTree], include: Include.Set, sym: Symbol)
    (implicit ctx: Context): List[SourceTree] =
     if (!sym.exists)
       Nil
     else
-      namedTrees(trees, includeReferences, matchSymbol(_, sym, includeOverridden))
+      namedTrees(trees, (include & Include.references) != 0, matchSymbol(_, sym, include))
 
   /** Find named trees with a non-empty position whose name contains `nameSubstring` in `trees`.
    *

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

@@ -24,6 +24,7 @@ import classpath.ClassPathEntries
 import reporting._, reporting.diagnostic.MessageContainer
 import util._
 import interactive._, interactive.InteractiveDriver._
+import Interactive.Include
 
 import languageserver.config.ProjectConfig
 
@@ -207,24 +208,27 @@ class DottyLanguageServer extends LanguageServer
       /*isIncomplete = */ false, items.map(completionItem).asJava))
   }
 
+  /** 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.
+   *  For performance reasons we currently look for overrides only in the file
+   *  where `sym` is defined.
+   */
   override def definition(params: TextDocumentPositionParams) = computeAsync { cancelToken =>
     val uri = new URI(params.getTextDocument.getUri)
     val driver = driverFor(uri)
     implicit val ctx = driver.currentCtx
 
     val pos = sourcePosition(driver, uri, params.getPosition)
-    val sym = Interactive.enclosingSourceSymbol(driver.openedTrees(uri), pos)
+    val enclTree = Interactive.enclosingTree(driver.openedTrees(uri), pos)
+    val sym = Interactive.sourceSymbol(enclTree.symbol)
 
     if (sym == NoSymbol) Nil.asJava
     else {
-      // This returns the position of sym as well as the overrides of sym, but
-      // for performance we only look for overrides in the file where sym is
-      // defined.
-      // We need a configuration option to choose how "go to definition" should
-      // behave with respect to overriding and overriden definitions, ideally
-      // this should be part of the LSP protocol.
       val trees = SourceTree.fromSymbol(sym.topLevelClass.asClass).toList
-      val defs = Interactive.namedTrees(trees, includeReferences = false, includeOverridden = true, sym)
+      var include = Include.overriding
+      if (enclTree.isInstanceOf[MemberDef]) include |= Include.overridden
+      val defs = Interactive.namedTrees(trees, include, sym)
       defs.map(d => location(d.namePos)).asJava
     }
   }
@@ -246,7 +250,7 @@ class DottyLanguageServer extends LanguageServer
       val trees = driver.allTreesContaining(sym.name.sourceModuleName.toString)
       val refs = Interactive.namedTrees(trees, includeReferences = true, (tree: tpd.NameTree) =>
         (includeDeclaration || !Interactive.isDefinition(tree))
-          && Interactive.matchSymbol(tree, sym, includeOverridden = true))
+          && Interactive.matchSymbol(tree, sym, Include.overriding))
 
       refs.map(ref => location(ref.namePos)).asJava
     }
@@ -267,8 +271,8 @@ class DottyLanguageServer extends LanguageServer
       val newName = params.getNewName
 
       val refs = Interactive.namedTrees(trees, includeReferences = true, tree =>
-        (Interactive.matchSymbol(tree, sym, includeOverridden = true)
-          || (linkedSym != NoSymbol && Interactive.matchSymbol(tree, linkedSym, includeOverridden = true))))
+        (Interactive.matchSymbol(tree, sym, Include.overriding)
+          || (linkedSym != NoSymbol && Interactive.matchSymbol(tree, linkedSym, Include.overriding))))
 
       val changes = refs.groupBy(ref => toUri(ref.source).toString).mapValues(_.map(ref => new TextEdit(range(ref.namePos), newName)).asJava)
 
@@ -287,7 +291,7 @@ class DottyLanguageServer extends LanguageServer
 
     if (sym == NoSymbol) Nil.asJava
     else {
-      val refs = Interactive.namedTrees(uriTrees, includeReferences = true, includeOverridden = true, sym)
+      val refs = Interactive.namedTrees(uriTrees, Include.references | Include.overriding, sym)
       refs.map(ref => new DocumentHighlight(range(ref.namePos), DocumentHighlightKind.Read)).asJava
     }
   }