Put doc and type info in separate hover

Author: Duhemm

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

@@ -349,8 +349,8 @@ class DottyLanguageServer extends LanguageServer
       import dotty.tools.dotc.core.Comments._
       val symbol = Interactive.enclosingSourceSymbol(trees, pos)
       val docComment = ctx.docCtx.flatMap(_.docstring(symbol))
-      val markedString = docMarkedString(docComment, tpw.show.toString)
-      new Hover(List(JEither.forRight(markedString)).asJava, null)
+      val markedStrings = docMarkedStrings(docComment, tpw.show.toString)
+      new Hover(markedStrings.map(JEither.forRight(_)).asJava, null)
     }
   }
 
@@ -467,18 +467,16 @@ object DottyLanguageServer {
     item
   }
 
-  private def docMarkedString(comment: Option[Comment], info: String): lsp4j.MarkedString = {
+  private def docMarkedStrings(comment: Option[Comment], typeInfo: String): List[lsp4j.MarkedString] = {
 
-    val formattedComment = comment.map { comment =>
-      s"""```scala
-         |${comment.raw}
-         |```
-         |""".stripMargin
-    }.getOrElse("")
+    val docHover = comment.map { comment =>
+      new lsp4j.MarkedString("scala", comment.raw)
+    }
+
+    val typeInfoHover = new lsp4j.MarkedString()
+    typeInfoHover.setValue(typeInfo)
 
-    val markedString = new lsp4j.MarkedString()
-    markedString.setValue(formattedComment + info)
-    markedString
+    docHover.toList :+ typeInfoHover
   }
 
 

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

@@ -7,63 +7,60 @@ import dotty.tools.languageserver.util.Code._
 class HoverTest {
 
   @Test def hoverOnWhiteSpace0: Unit =
-    code"$m1 $m2".withSource.hover(m1 to m2, "")
+    code"$m1 $m2".withSource.hover(m1 to m2, Nil)
 
   @Test def hoverOnClassShowsDoc: Unit = {
     code"""$m1 /** foo */ ${m2}class Foo $m3 $m4""".withSource
-      .hover(m1 to m2, "")
-      .hover(m2 to m3, """```scala
-                         |/** foo */
-                         |```
-                         |Foo""".stripMargin)
-      .hover(m3 to m4, "")
+      .hover(m1 to m2, Nil)
+      .hover(m2 to m3, List("/** foo */", "Foo"))
+      .hover(m3 to m4, Nil)
   }
 
   @Test def hoverOnClass0: Unit = {
     code"""$m1 ${m2}class Foo $m3 $m4""".withSource
-      .hover(m1 to m2, "")
-      .hover(m2 to m3, "Foo")
-      .hover(m3 to m4, "")
+      .hover(m1 to m2, Nil)
+      .hover(m2 to m3, "Foo" :: Nil)
+      .hover(m3 to m4, Nil)
   }
 
   @Test def hoverOnClass1: Unit = {
     code"""$m1 ${m2}class Foo { } $m3 $m4""".withSource
-      .hover(m1 to m2, "")
-      .hover(m2 to m3, "Foo")
-      .hover(m3 to m4, "")
+      .hover(m1 to m2, Nil)
+      .hover(m2 to m3, "Foo" :: Nil)
+      .hover(m3 to m4, Nil)
   }
 
   @Test def hoverOnValDef0: Unit = {
     code"""class Foo {
           |  ${m1}val x = ${m2}8$m3; ${m4}x$m5
           |}""".withSource
-      .hover(m1 to m2, "Int")
-      .hover(m2 to m3, "Int(8)")
-      .hover(m4 to m5, "Int")
+      .hover(m1 to m2, "Int" :: Nil)
+      .hover(m2 to m3, "Int(8)" :: Nil)
+      .hover(m4 to m5, "Int" :: Nil)
   }
 
   @Test def hoverOnValDef1: Unit = {
     code"""class Foo {
           |  ${m1}final val x = 8$m2; ${m3}x$m4
           |}""".withSource
-      .hover(m1 to m2, "Int(8)")
-      .hover(m3 to m4, "Int(8)")
+      .hover(m1 to m2, "Int(8)" :: Nil)
+      .hover(m3 to m4, "Int(8)" :: Nil)
   }
 
   @Test def hoverOnDefDef0: Unit = {
     code"""class Foo {
           |  ${m1}def x = ${m2}8$m3; ${m4}x$m5
           |}""".withSource
-      .hover(m1 to m2, "Int")
-      .hover(m2 to m3, "Int(8)")
-      .hover(m4 to m5, "Int")
+      .hover(m1 to m2, "Int" :: Nil)
+      .hover(m2 to m3, "Int(8)" :: Nil)
+      .hover(m4 to m5, "Int" :: Nil)
   }
 
   @Test def hoverMissingRef0: Unit = {
     code"""class Foo {
           |  ${m1}x$m2
           |}""".withSource
-      .hover(m1 to m2, "<error not found: x>")
+      .hover(m1 to m2, "<error not found: x>" :: Nil)
   }
 
   @Test def hoverFun0: Unit = {
@@ -75,10 +72,10 @@ class HoverTest {
           |  ${m5}y($m6)$m7
           |}
         """.withSource
-      .hover(m1 to m2, "String(\"abc\")")
-      .hover(m3 to m4, "String")
-      .hover(m5 to m6, "(): Int")
-      .hover(m6 to m7, "Int")
+      .hover(m1 to m2, "String(\"abc\")" :: Nil)
+      .hover(m3 to m4, "String" :: Nil)
+      .hover(m5 to m6, "(): Int" :: Nil)
+      .hover(m6 to m7, "Int" :: Nil)
   }
 
 }

language-server/test/dotty/tools/languageserver/util/CodeTester.scala

@@ -25,11 +25,11 @@ class CodeTester(sources: List[SourceWithPositions], actions: List[Action]) {
    * Perform a hover over `range`, verifies that result matches `expected`.
    *
    * @param range    The range over which to hover.
-   * @param expected The expected result.
+   * @param expected The expected results.
    *
    * @see dotty.tools.languageserver.util.actions.CodeHover
    */
-  def hover(range: CodeRange, expected: String): this.type =
+  def hover(range: CodeRange, expected: List[String]): this.type =
     doAction(new CodeHover(range, expected))
 
   /**

language-server/test/dotty/tools/languageserver/util/actions/CodeHover.scala

@@ -5,25 +5,27 @@ import dotty.tools.languageserver.util.{CodeRange, PositionContext}
 
 import org.junit.Assert.{assertEquals, assertNull, assertTrue}
 
+import scala.collection.JavaConverters._
+
 /**
  * An action requesting for the info shown when `range` is hovered.
  * This action corresponds to the `textDocument/hover` method of the Language Server Protocol.
  *
  * @param range The range of positions that should be hovered.
  * @param expected The expected result.
  */
-class CodeHover(override val range: CodeRange, expected: String) extends ActionOnRange {
+class CodeHover(override val range: CodeRange, expected: List[String]) extends ActionOnRange {
 
   override def onMarker(marker: CodeMarker): Exec[Unit] = {
     val result = server.hover(marker.toTextDocumentPositionParams).get()
     assertNull(result.getRange)
     if (expected.isEmpty) assertNull(result.getContents)
     else {
-      assertEquals(1, result.getContents.size)
-      val content = result.getContents.get(0)
-      assertTrue(content.isRight)
-      val markedString = content.getRight.getValue
-      assertEquals(expected, markedString)
+      assertEquals(expected.size, result.getContents.size)
+      expected.zip(result.getContents.asScala).foreach { case (expected, actual) =>
+        assertTrue(actual.isRight)
+        assertEquals(expected, actual.getRight.getValue)
+      }
     }
   }