Handle overridden symbols in doc command in REPL

Author: Duhemm

compiler/src/dotty/tools/repl/ReplCompiler.scala

@@ -155,30 +155,43 @@ class ReplCompiler(val directory: AbstractFile) extends Compiler {
   def docOf(expr: String)(implicit state: State): Result[String] = {
     implicit val ctx: Context = state.run.runContext
 
-    def pickSymbol(symbol: Symbol): Symbol = {
-      if (symbol.is(Module, butNot = ModuleClass)) symbol.moduleClass
-      if (symbol.isConstructor) symbol.owner
-      else symbol
-    }
-
+    /** Extract the (possibly) documented symbol from `tree` */
     def extractSymbol(tree: tpd.Tree): Symbol = {
       tree match {
         case tpd.closureDef(defdef) => defdef.rhs.symbol
         case _ => tree.symbol
       }
     }
 
+    /**
+     * Adapt `symbol` so that we get the one that holds the documentation.
+     * Return also the symbols that `symbol` overrides`.
+     */
+    def pickSymbols(symbol: Symbol): Iterator[Symbol] = {
+      val selectedSymbol = {
+        if (symbol.is(Module, butNot = ModuleClass)) symbol.moduleClass
+        if (symbol.isConstructor) symbol.owner
+        else symbol
+      }
+
+      Iterator(selectedSymbol) ++ selectedSymbol.allOverriddenSymbols
+    }
+
     typeCheck(expr).map {
       case v @ ValDef(_, _, Block(stats, _)) if stats.nonEmpty =>
         val stat = stats.last.asInstanceOf[tpd.Tree]
         if (stat.tpe.isError) stat.tpe.show
         else {
-          val symbol = pickSymbol(extractSymbol(stat))
           val doc =
-            for { docCtx <- ctx.docCtx
-            doc <- docCtx.docstrings.get(symbol) } yield doc.raw
-
-            doc.getOrElse(s"// No doc for ${symbol.show}")
+            ctx.docCtx.flatMap { docCtx =>
+              val symbols = pickSymbols(extractSymbol(stat))
+              symbols.collectFirst {
+                case sym if docCtx.docstrings.contains(sym) =>
+                  docCtx.docstrings(sym).raw
+              }
+            }
+
+            doc.getOrElse(s"// No doc for `${expr}`")
         }
 
       case _ =>

compiler/test/dotty/tools/repl/DocTests.scala

@@ -142,4 +142,51 @@ class DocTests extends ReplTest {
               .fold(onErrors, assertEquals("/** doc */", _))
     }
 
+  @Test def docOfOverride =
+    fromInitialState { implicit s =>
+      compile("""abstract class A {
+                |/** doc0 */ def foo(x: Int): Int = x + 1
+                |/** doc1 */ def foo(x: String): String = x + "foo"
+                |}""".stripMargin)
+    }
+    .andThen { implicit s =>
+      compile("""object O extends A {
+                |  override def foo(x: Int): Int = x
+                |  /** overridden doc */ override def foo(x: String): String = x
+                |}""".stripMargin)
+    }
+    .andThen { implicit s =>
+      compiler.docOf("O.foo(_: Int)")
+              .fold(onErrors, assertEquals("/** doc0 */", _))
+      s
+    }
+    .andThen { implicit s =>
+      compiler.docOf("O.foo(_: String)")
+              .fold(onErrors, assertEquals("/** overridden doc */", _))
+    }
+
+  @Test def docOfOverrideObject =
+    fromInitialState { implicit s =>
+      compile("""abstract class A {
+                |  abstract class Companion { /** doc0 */ def bar: Int }
+                |  /** companion */ def foo: Companion
+                |}""".stripMargin)
+      .andThen { implicit s =>
+        compile("""object O extends A {
+                  |  override object foo extends Companion {
+                  |    override def bar: Int = 0
+                  |  }
+                  |}""".stripMargin)
+      }
+      .andThen { implicit s =>
+        compiler.docOf("O.foo")
+                .fold(onErrors, assertEquals("/** companion */", _))
+        s
+      }
+      .andThen { implicit s =>
+        compiler.docOf("O.foo.bar")
+                .fold(onErrors, assertEquals("/** doc0 */", _))
+      }
+    }
+
 }