Provide completion and errors analysis for commands

Fixes #90

Author: ileasile

src/main/kotlin/org/jetbrains/kotlin/jupyter/commands.kt

@@ -1,6 +1,14 @@
 package org.jetbrains.kotlin.jupyter
 
 import jupyter.kotlin.textResult
+import org.jetbrains.kotlin.jupyter.repl.completion.CompletionResult
+import org.jetbrains.kotlin.jupyter.repl.completion.KotlinCompleter
+import org.jetbrains.kotlin.jupyter.repl.completion.ListErrorsResult
+import org.jetbrains.kotlin.jupyter.repl.completion.SourceCodeImpl
+import kotlin.script.experimental.api.ScriptDiagnostic
+import kotlin.script.experimental.api.SourceCode
+import kotlin.script.experimental.api.SourceCodeCompletionVariant
+import kotlin.script.experimental.jvm.util.toSourceCodePosition
 
 enum class ReplCommands(val desc: String) {
     help("display help"),
@@ -9,17 +17,43 @@ enum class ReplCommands(val desc: String) {
 
 fun isCommand(code: String): Boolean = code.startsWith(":")
 
+fun getCommand(string: String): ReplCommands? {
+    return try {
+        ReplCommands.valueOf(string)
+    } catch (e: IllegalArgumentException) {
+        null
+    }
+}
+
 fun <T> Iterable<T>.joinToStringIndented(transform: ((T) -> CharSequence)? = null) = joinToString("\n    ", prefix = "    ", transform = transform)
 
+fun reportCommandErrors(code: String): ListErrorsResult {
+    val commandString = code.trim().substring(1)
+    val command = getCommand(commandString)
+    if (command != null) return ListErrorsResult(code)
+
+    val sourceCode = SourceCodeImpl(0, code)
+    val location = SourceCode.Location(
+            0.toSourceCodePosition(sourceCode),
+            (commandString.length + 1).toSourceCodePosition(sourceCode)
+    )
+    return ListErrorsResult(code, sequenceOf(
+            ScriptDiagnostic(ScriptDiagnostic.unspecifiedError, "Unknown command", location = location)
+    ))
+}
+
+fun doCommandCompletion(code: String, cursor: Int): CompletionResult {
+    val prefix = code.substring(1, cursor)
+    val suitableCommands = ReplCommands.values().filter { it.name.startsWith(prefix) }
+    val completions = suitableCommands.map {
+        SourceCodeCompletionVariant(it.name, it.name, "command", "command")
+    }
+    return KotlinCompleter.getResult(code, cursor, completions)
+}
+
 fun runCommand(code: String, repl: ReplForJupyter?): Response {
     val args = code.trim().substring(1).split(" ")
-    val cmd =
-            try {
-                ReplCommands.valueOf(args[0])
-            }
-            catch (e: IllegalArgumentException) {
-                return AbortResponseWithMessage(textResult("Failed!"), "unknown command: $code\nto see available commands, enter :help")
-            }
+    val cmd = getCommand(args[0]) ?: return AbortResponseWithMessage(textResult("Failed!"), "unknown command: $code\nto see available commands, enter :help")
     return when (cmd) {
         ReplCommands.classpath -> {
             val cp = repl!!.currentClasspath

src/main/kotlin/org/jetbrains/kotlin/jupyter/repl.kt

@@ -444,17 +444,27 @@ class ReplForJupyterImpl(private val scriptClasspath: List<File> = emptyList(),
     }
 
     private val completionQueue = LockQueue<CompletionResult, CompletionArgs>()
-    override suspend fun complete(code: String, cursor: Int, callback: (CompletionResult) -> Unit) = doWithLock(CompletionArgs(code, cursor, callback), completionQueue, CompletionResult.Empty(code, cursor)) {
-        val preprocessed = magics.processMagics(code, true).code
-        completer.complete(compiler, compilerConfiguration, code, preprocessed, executionCounter++, cursor)
+    override suspend fun complete(code: String, cursor: Int, callback: (CompletionResult) -> Unit) =
+            doWithLock(CompletionArgs(code, cursor, callback), completionQueue, CompletionResult.Empty(code, cursor), ::doComplete)
+
+    private fun doComplete(args: CompletionArgs): CompletionResult {
+        if (isCommand(args.code)) return doCommandCompletion(args.code, args.cursor)
+
+        val preprocessed = magics.processMagics(args.code, true).code
+        return completer.complete(compiler, compilerConfiguration, args.code, preprocessed, executionCounter++, args.cursor)
     }
 
     private val listErrorsQueue = LockQueue<ListErrorsResult, ListErrorsArgs>()
-    override suspend fun listErrors(code: String, callback: (ListErrorsResult) -> Unit) = doWithLock(ListErrorsArgs(code, callback), listErrorsQueue, ListErrorsResult(code)) {
-        val preprocessed = magics.processMagics(code, true).code
+    override suspend fun listErrors(code: String, callback: (ListErrorsResult) -> Unit) =
+            doWithLock(ListErrorsArgs(code, callback), listErrorsQueue, ListErrorsResult(code), ::doListErrors)
+
+    private fun doListErrors(args: ListErrorsArgs): ListErrorsResult {
+        if (isCommand(args.code)) return reportCommandErrors(args.code)
+
+        val preprocessed = magics.processMagics(args.code, true).code
         val codeLine = SourceCodeImpl(executionCounter++, preprocessed)
         val errorsList = runBlocking { compiler.analyze(codeLine, 0.toSourceCodePosition(codeLine), compilerConfiguration) }
-        ListErrorsResult(code, errorsList.valueOrThrow()[ReplAnalyzerResult.analysisDiagnostics]!!)
+        return ListErrorsResult(args.code, errorsList.valueOrThrow()[ReplAnalyzerResult.analysisDiagnostics]!!)
     }
 
     private fun <T, Args: LockQueueArgs<T>> doWithLock(args: Args, queue: LockQueue<T, Args>, default: T, action: (Args) -> T) {

src/main/kotlin/org/jetbrains/kotlin/jupyter/repl/completion/KotlinCompleter.kt

@@ -129,8 +129,7 @@ class KotlinCompleter {
             val completionResult = codePos?.let { runBlocking { compiler.complete(preprocessedCodeLine, codePos, configuration) } }
 
             completionResult?.valueOrNull()?.toList()?.let { completionList ->
-                val bounds = getTokenBounds(code, cursor)
-                CompletionResult.Success(completionList.map { it.text }, bounds, completionList, code, cursor)
+                getResult(code, cursor, completionList)
             } ?: CompletionResult.Empty(code, cursor)
 
         } catch (e: Exception) {
@@ -141,6 +140,11 @@ class KotlinCompleter {
     }
 
     companion object {
+        fun getResult(code: String, cursor: Int, completions: List<SourceCodeCompletionVariant>): CompletionResult.Success {
+            val bounds = getTokenBounds(code, cursor)
+            return CompletionResult.Success(completions.map { it.text }, bounds, completions, code, cursor)
+        }
+
         private fun getTokenBounds(buf: String, cursor: Int): CompletionTokenBounds {
             require(cursor <= buf.length) { "Position $cursor does not exist in code snippet <$buf>" }
 

src/main/kotlin/org/jetbrains/kotlin/jupyter/util.kt

@@ -5,6 +5,7 @@ import kotlinx.coroutines.GlobalScope
 import kotlinx.coroutines.async
 import kotlinx.coroutines.runBlocking
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageLocationWithRange
+import org.jetbrains.kotlin.jupyter.repl.completion.SourceCodeImpl
 import org.slf4j.Logger
 import java.io.File
 import kotlin.script.experimental.api.ResultWithDiagnostics
@@ -54,6 +55,17 @@ fun generateDiagnostic(fromLine: Int, fromCol: Int, toLine: Int, toCol: Int, mes
                 SourceCode.Location(SourceCode.Position(fromLine, fromCol), SourceCode.Position(toLine, toCol))
         )
 
+fun generateDiagnosticFromAbsolute(code: String, from: Int, to: Int, message: String, severity: String): ScriptDiagnostic {
+    val snippet = SourceCodeImpl(0, code)
+    return ScriptDiagnostic(
+            ScriptDiagnostic.unspecifiedError,
+            message,
+            ScriptDiagnostic.Severity.valueOf(severity),
+            null,
+            SourceCode.Location(from.toSourceCodePosition(snippet), to.toSourceCodePosition(snippet))
+    )
+}
+
 fun withPath(path: String?, diagnostics: List<ScriptDiagnostic>): List<ScriptDiagnostic> =
         diagnostics.map { it.copy(sourcePath = path) }
 

src/test/kotlin/org/jetbrains/kotlin/jupyter/test/replTests.kt

@@ -12,6 +12,7 @@ import org.jetbrains.kotlin.jupyter.ReplForJupyterImpl
 import org.jetbrains.kotlin.jupyter.ResolverConfig
 import org.jetbrains.kotlin.jupyter.defaultRepositories
 import org.jetbrains.kotlin.jupyter.generateDiagnostic
+import org.jetbrains.kotlin.jupyter.generateDiagnosticFromAbsolute
 import org.jetbrains.kotlin.jupyter.repl.completion.CompletionResult
 import org.jetbrains.kotlin.jupyter.repl.completion.ListErrorsResult
 import org.jetbrains.kotlin.jupyter.runtimeProperties
@@ -270,6 +271,32 @@ class ReplTest : AbstractReplTest() {
         }
     }
 
+    @Test
+    fun testCommands() {
+        val code1 = ":help"
+        val code2 = ":hex "
+
+        runBlocking {
+            repl.listErrors(code1) { result ->
+                assertEquals(code1, result.code)
+                assertEquals(0, result.errors.toList().size)
+            }
+            repl.listErrors(code2) { result ->
+                assertEquals(code2, result.code)
+                val expectedList = listOf(generateDiagnosticFromAbsolute(code2, 0, 4, "Unknown command", "ERROR"))
+                val actualList = result.errors.toList()
+                assertEquals(expectedList, actualList)
+            }
+            repl.complete(code2, 3) { result ->
+                if (result is CompletionResult.Success) {
+                    assertEquals(listOf("help"), result.sortedMatches())
+                } else {
+                    fail("Result should be success")
+                }
+            }
+        }
+    }
+
     @Test
     fun testEmptyErrorsListJson() {
         val res = ListErrorsResult("someCode")