Better completion description for multiple symbols

When multiple symbols are concerned by one completion result, we show
the different kinds of symbols.

Author: Duhemm

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

@@ -149,24 +149,39 @@ object Completion {
       val groupedSymbols = {
         val symbols = completions.toListWithNames
         val nameToSymbols = symbols.groupBy(_._2.stripModuleClassSuffix.toSimpleName)
-        nameToSymbols.mapValues(_.map(_._1)).toList
+        nameToSymbols.mapValues { symbols =>
+          symbols
+            .map(_._1)
+            .distinct // Show symbols that have been renamed multiple times only once
+        }.toList
       }
       groupedSymbols.map { case (name, symbols) =>
-        val typesFirst = symbols.sortWith((s, _) => s.isType)
-        // Use distinct to remove duplicates with class, module class, etc.
-        val descriptions = typesFirst.map(description).distinct.mkString(", ")
-        Completion(name.toString, descriptions, typesFirst)
+        val typesFirst = symbols.sortWith((s1, s2) => s1.isType && !s2.isType)
+        val desc = description(typesFirst)
+        Completion(name.toString, desc, typesFirst)
       }
     }
 
     /**
-     * A description for `sym`.
+     * A description for completion result that represents `symbols`.
      *
-     * For types, show the symbol's full name, or its type for term symbols.
+     * If `symbols` contains a single symbol, show its full name in case it's a type, or its type if
+     * it's a term.
+     *
+     * When there are multiple symbols, show their kinds.
      */
-    private def description(sym: Symbol)(implicit ctx: Context): String = {
-      if (sym.isType) sym.showFullName
-      else sym.info.widenTermRefExpr.show
+    private def description(symbols: List[Symbol])(implicit ctx: Context): String = {
+      symbols match {
+        case sym :: Nil =>
+          if (sym.isType) sym.showFullName
+          else sym.info.widenTermRefExpr.show
+
+        case sym :: _ =>
+          symbols.map(ctx.printer.kindString).mkString("", " and ", s" ${sym.name.show}")
+
+        case Nil =>
+          ""
+      }
     }
 
     /**

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

@@ -89,7 +89,7 @@ class CompletionTest {
              object Foo""",
       code"""package pgk1
              import pkg0.F${m1}"""
-    ).completion(m1, Set(("Foo", Class, "pkg0.Foo")))
+    ).completion(m1, Set(("Foo", Class, "class and object Foo")))
   }
 
   @Test def importCompleteIncludePackage: Unit = {
@@ -121,7 +121,7 @@ class CompletionTest {
 
   @Test def importJavaClass: Unit = {
     code"""import java.io.FileDesc${m1}""".withSource
-      .completion(m1, Set(("FileDescriptor", Class, "java.io.FileDescriptor")))
+      .completion(m1, Set(("FileDescriptor", Class, "class and object FileDescriptor")))
   }
 
   @Test def importJavaStaticMethod: Unit = {
@@ -143,7 +143,7 @@ class CompletionTest {
 
   @Test def importRename: Unit = {
     code"""import java.io.{FileDesc${m1} => Foo}""".withSource
-      .completion(m1, Set(("FileDescriptor", Class, "java.io.FileDescriptor")))
+      .completion(m1, Set(("FileDescriptor", Class, "class and object FileDescriptor")))
   }
 
   @Test def markDeprecatedSymbols: Unit = {
@@ -203,7 +203,7 @@ class CompletionTest {
   @Test def completionOnRenamedImport: Unit = {
     code"""import java.io.{FileDescriptor => AwesomeStuff}
            trait Foo { val x: Awesom$m1 }""".withSource
-      .completion(m1, Set(("AwesomeStuff", Class, "java.io.FileDescriptor")))
+      .completion(m1, Set(("AwesomeStuff", Class, "class and object FileDescriptor")))
   }
 
   @Test def completionOnRenamedImport2: Unit = {
@@ -212,7 +212,7 @@ class CompletionTest {
              import java.io.{FileDescriptor => MyImportedSymbol}
              val x: MyImp$m1
            }""".withSource
-      .completion(m1, Set(("MyImportedSymbol", Class, "java.io.FileDescriptor")))
+      .completion(m1, Set(("MyImportedSymbol", Class, "class and object FileDescriptor")))
   }
 
   @Test def completionRenamedAndOriginalNames: Unit = {
@@ -221,8 +221,8 @@ class CompletionTest {
           |  import java.util.{HashMap => HashMap2}
           |  val x: Hash$m1
           |}""".withSource
-      .completion(m1, Set(("HashMap", Class, "java.util.HashMap"),
-                          ("HashMap2", Class, "java.util.HashMap")))
+      .completion(m1, Set(("HashMap", Class, "class and object HashMap"),
+                          ("HashMap2", Class, "class and object HashMap")))
   }
 
   @Test def completionRenamedThrice: Unit = {
@@ -232,8 +232,26 @@ class CompletionTest {
           |  import java.util.{HashMap => MyHashMap3}
           |  val x: MyHash$m1
           |}""".withSource
-      .completion(m1, Set(("MyHashMap", Class, "java.util.HashMap"),
-                          ("MyHashMap2", Class, "java.util.HashMap"),
-                          ("MyHashMap3", Class, "java.util.HashMap")))
+      .completion(m1, Set(("MyHashMap", Class, "class and object HashMap"),
+                          ("MyHashMap2", Class, "class and object HashMap"),
+                          ("MyHashMap3", Class, "class and object HashMap")))
+  }
+
+  @Test def completionClassAndMethod: Unit = {
+    code"""object Foo {
+          |  class bar
+          |  def bar = 0
+          |}
+          |import Foo.b$m1""".withSource
+      .completion(m1, Set(("bar", Class, "class and method bar")))
+  }
+
+  @Test def completionTypeAndLazyValue: Unit = {
+    code"""object Foo {
+          |  type bar = Int
+          |  lazy val bar = 3
+          |}
+          |import Foo.b$m1""".withSource
+      .completion(m1, Set(("bar", Field, "type and lazy value bar")))
   }
 }