Improve display of completion results

When available, we display the formatted documentation for the imported
symbol.

For type symbols, we display the full name of the symbol, and for term
symbols we show their type.

Author: Duhemm

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

@@ -794,12 +794,16 @@ object DottyLanguageServer {
 
     val label = sym.name.show
     val item = new lsp4j.CompletionItem(label)
-    item.setDetail(sym.info.widenTermRefExpr.show)
+    val detail = if (sym.isType) sym.showFullName else sym.info.widenTermRefExpr.show
+    item.setDetail(detail)
+    ParsedComment.docOf(sym).foreach { doc =>
+      item.setDocumentation(markupContent(doc.renderAsMarkdown))
+    }
     item.setKind(completionItemKind(sym))
     item
   }
 
-  def hoverContent(content: String): lsp4j.MarkupContent = {
+  def markupContent(content: String): lsp4j.MarkupContent = {
     if (content.isEmpty) null
     else {
       val markup = new lsp4j.MarkupContent
@@ -823,7 +827,7 @@ object DottyLanguageServer {
       buf.append(comment.renderAsMarkdown)
     }
 
-    hoverContent(buf.toString)
+    markupContent(buf.toString)
   }
 
   /** Create an lsp4j.SymbolInfo from a Symbol and a SourcePosition */
@@ -868,7 +872,7 @@ object DottyLanguageServer {
     val tparamsLabel = if (signature.tparams.isEmpty) "" else signature.tparams.mkString("[", ", ", "]")
     val returnTypeLabel = signature.returnType.map(t => s": $t").getOrElse("")
     val label = s"${signature.name}$tparamsLabel$paramLists$returnTypeLabel"
-    val documentation = signature.doc.map(DottyLanguageServer.hoverContent)
+    val documentation = signature.doc.map(DottyLanguageServer.markupContent)
     val sig = new lsp4j.SignatureInformation(label)
     sig.setParameters(paramInfoss.flatten.asJava)
     documentation.foreach(sig.setDocumentation(_))
@@ -877,7 +881,7 @@ object DottyLanguageServer {
 
   /** Convert `param` to `ParameterInformation` */
   private def paramToParameterInformation(param: Signatures.Param): lsp4j.ParameterInformation = {
-    val documentation = param.doc.map(DottyLanguageServer.hoverContent)
+    val documentation = param.doc.map(DottyLanguageServer.markupContent)
     val info = new lsp4j.ParameterInformation(param.show)
     documentation.foreach(info.setDocumentation(_))
     info

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

@@ -25,16 +25,16 @@ class CompletionTest {
     withSources(
       code"""object Foo { class MyClass }""",
       code"""import Foo.My${m1}"""
-    ).completion(m1, Set(("MyClass", Class, "Object{...}")))
+    ).completion(m1, Set(("MyClass", Class, "Foo.MyClass")))
   }
 
   @Test def ImportCompleteClassNoPrefix: Unit = {
     withSources(
       code"""object Foo { class MyClass }""",
       code"""import Foo.${m1}"""
     ).completion(m1, results => {
-      val myClass = ("MyClass", Class, "Object{...}")
-      assertTrue(results.contains(("MyClass", Class, "Object{...}")))
+      val myClass = ("MyClass", Class, "Foo.MyClass")
+      assertTrue(results.contains(("MyClass", Class, "Foo.MyClass")))
 
       // Verify that apart from `MyClass`, we only have the methods that exists on `Foo`
       assertTrue((results - myClass).forall { case (_, kind, _) => kind == Method })
@@ -50,7 +50,7 @@ class CompletionTest {
              class MyClass""",
       code"""package b
              import a.My${m1}"""
-    ).completion(m1, Set(("MyClass", Class, "Object{...}")))
+    ).completion(m1, Set(("MyClass", Class, "a.MyClass")))
   }
 
   @Test def importCompleteFromClass: Unit = {
@@ -87,15 +87,15 @@ class CompletionTest {
              object Foo""",
       code"""package pgk1
              import pkg0.F${m1}"""
-    ).completion(m1, Set(("Foo", Class, "Object{...}")))
+    ).completion(m1, Set(("Foo", Class, "pkg0.Foo")))
   }
 
   @Test def importCompleteIncludePackage: Unit = {
     withSources(
       code"""package foo.bar
              class Fizz""",
       code"""import foo.b${m1}"""
-    ).completion(m1, Set(("bar", Module, "{...}")))
+    ).completion(m1, Set(("bar", Module, "foo.bar")))
   }
 
   @Test def importCompleteIncludeMembers: Unit = {
@@ -113,13 +113,13 @@ class CompletionTest {
                          ("myDef", Method, "=> Int"),
                          ("myVar", Variable, "Int"),
                          ("myObject", Module, "MyObject.myObject"),
-                         ("myClass", Class, "Object{...}"),
-                         ("myTrait", Class, "Object{...}")))
+                         ("myClass", Class, "MyObject.myClass"),
+                         ("myTrait", Class, "MyObject.myTrait")))
   }
 
   @Test def importJavaClass: Unit = {
     code"""import java.io.FileDesc${m1}""".withSource
-      .completion(m1, Set(("FileDescriptor", Class, "Object{...}")))
+      .completion(m1, Set(("FileDescriptor", Class, "java.io.FileDescriptor")))
   }
 
   @Test def importJavaStaticMethod: Unit = {
@@ -141,6 +141,6 @@ class CompletionTest {
 
   @Test def importRename: Unit = {
     code"""import java.io.{FileDesc${m1} => Foo}""".withSource
-      .completion(m1, Set(("FileDescriptor", Class, "Object{...}")))
+      .completion(m1, Set(("FileDescriptor", Class, "java.io.FileDescriptor")))
   }
 }