feat(repl): method signatures in autocomplete

Author: Florian3k

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

@@ -31,6 +31,7 @@ import dotty.tools.dotc.util.{SourceFile, SourcePosition}
 import dotty.tools.dotc.{CompilationUnit, Driver}
 import dotty.tools.dotc.config.CompilerCommand
 import dotty.tools.io.*
+import dotty.tools.repl.Rendering.showUser
 import dotty.tools.runner.ScalaClassLoader.*
 import org.jline.reader.*
 
@@ -149,11 +150,38 @@ class ReplDriver(settings: Array[String],
 
     /** Blockingly read a line, getting back a parse result */
     def readLine()(using state: State): ParseResult = {
-      val completer: Completer = { (_, line, candidates) =>
-        val comps = completions(line.cursor, line.line, state)
-        candidates.addAll(comps.asJava)
-      }
       given Context = state.context
+      val completer: Completer = { (lineReader, line, candidates) =>
+        def makeCandidate(label: String) = {
+          new Candidate(
+            /* value    = */ label,
+            /* displ    = */ stripBackTicks(label), // displayed value
+            /* group    = */ null,  // can be used to group completions together
+            /* descr    = */ null,  // TODO use for documentation?
+            /* suffix   = */ null,
+            /* key      = */ null,
+            /* complete = */ false  // if true adds space when completing
+          )
+        }
+        completions(line.cursor, line.line, state) match
+          case Left(cmds) => candidates.addAll(cmds.map(makeCandidate).asJava)
+          case Right(comps) =>
+            val lineWord = line.word()
+            candidates.addAll(comps.map(c => makeCandidate(c.label)).asJava)
+            comps.filter(_.label == lineWord) match
+              case Nil =>
+              case exachMatches =>
+                val terminal = lineReader.getTerminal
+                lineReader.callWidget(LineReader.CLEAR)
+                terminal.writer.println()
+                exachMatches.foreach: exact =>
+                  exact.symbols.foreach: sym =>
+                    terminal.writer.println(SyntaxHighlighting.highlight(sym.showUser))
+                lineReader.callWidget(LineReader.REDRAW_LINE)
+                lineReader.callWidget(LineReader.REDISPLAY)
+                terminal.flush()
+      }
+
       try {
         val line = terminal.readLine(completer)
         ParseResult(line)
@@ -230,39 +258,26 @@ class ReplDriver(settings: Array[String],
       label
 
   /** Extract possible completions at the index of `cursor` in `expr` */
-  protected final def completions(cursor: Int, expr: String, state0: State): List[Candidate] =
-    def makeCandidate(label: String) = {
-
-      new Candidate(
-        /* value    = */ label,
-        /* displ    = */ stripBackTicks(label), // displayed value
-        /* group    = */ null,  // can be used to group completions together
-        /* descr    = */ null,  // TODO use for documentation?
-        /* suffix   = */ null,
-        /* key      = */ null,
-        /* complete = */ false  // if true adds space when completing
-      )
-    }
-
+  protected final def completions(cursor: Int, expr: String, state0: State): Either[List[String], List[Completion]] =
     if expr.startsWith(":") then
-      ParseResult.commands.collect {
-        case command if command._1.startsWith(expr) => makeCandidate(command._1)
-      }
+      Left(ParseResult.commands.collect {
+        case command if command._1.startsWith(expr) => command._1
+      })
     else
       given state: State = newRun(state0)
-      compiler
-        .typeCheck(expr, errorsAllowed = true)
-        .map { (untpdTree, tpdTree) =>
-          val file = SourceFile.virtual("<completions>", expr, maybeIncomplete = true)
-          val unit = CompilationUnit(file)(using state.context)
-          unit.untpdTree = untpdTree
-          unit.tpdTree = tpdTree
-          given Context = state.context.fresh.setCompilationUnit(unit)
-          val srcPos = SourcePosition(file, Span(cursor))
-          val completions = try Completion.completions(srcPos)._2 catch case NonFatal(_) => Nil
-          completions.map(_.label).distinct.map(makeCandidate)
-        }
-        .getOrElse(Nil)
+      Right:
+        compiler
+          .typeCheck(expr, errorsAllowed = true)
+          .map { (untpdTree, tpdTree) =>
+            val file = SourceFile.virtual("<completions>", expr, maybeIncomplete = true)
+            val unit = CompilationUnit(file)(using state.context)
+            unit.untpdTree = untpdTree
+            unit.tpdTree = tpdTree
+            given Context = state.context.fresh.setCompilationUnit(unit)
+            val srcPos = SourcePosition(file, Span(cursor))
+            try Completion.completions(srcPos)._2 catch case NonFatal(_) => Nil
+          }
+          .getOrElse(Nil)
   end completions
 
   protected def interpret(res: ParseResult, quiet: Boolean = false)(using state: State): State = {

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

@@ -42,7 +42,9 @@ extends ReplDriver(options, new PrintStream(out, true, StandardCharsets.UTF_8.na
 
   /** Returns the `(<instance completions>, <companion completions>)`*/
   def tabComplete(src: String)(implicit state: State): List[String] =
-    completions(src.length, src, state).map(_.value).sorted
+    completions(src.length, src, state) match
+      case Left(cmds) => cmds
+      case Right(comps) => comps.map(_.label)
 
   extension [A](state: State)
     infix def andThen(op: State ?=> A): A = op(using state)