KTL-3015 implement Kotlin LSP proxy for completions

.gitignore

@@ -37,3 +37,5 @@ out/
 
 ### VS Code ###
 .vscode/
+
+kotlin-lsp/

build.gradle.kts

@@ -12,10 +12,7 @@ version = "${libs.versions.kotlin.get()}-SNAPSHOT"
 val propertyFile = "application.properties"
 
 plugins {
-    alias(libs.plugins.spring.boot)
-    alias(libs.plugins.spring.dependency.management)
-    alias(libs.plugins.kotlin.plugin.spring)
-    id("base-kotlin-jvm-conventions")
+    id("base-spring-boot-conventions")
 }
 
 apply<NodeJsRootPlugin>()
@@ -40,7 +37,7 @@ dependencies {
     implementation("org.springframework.boot:spring-boot-starter-web")
     implementation("org.springframework.boot:spring-boot-starter-validation")
     implementation(libs.aws.springboot.container)
-    implementation(libs.springdoc)
+    implementation(libs.springdoc.webmvc)
     implementation(libs.gson)
     implementation(libs.kotlinx.serialization.json)
     implementation(libs.kotlin.compiler.arguments.description)
@@ -58,9 +55,6 @@ dependencies {
     implementation(project(":dependencies"))
 
     testImplementation(libs.kotlin.test)
-    testImplementation("org.springframework.boot:spring-boot-starter-test") {
-        exclude(group = "org.junit.vintage", module = "junit-vintage-engine")
-    }
     testImplementation(libs.kotlinx.coroutines.test)
 
     resourceDependency(libs.skiko.js.wasm.runtime)
@@ -93,12 +87,6 @@ fun generateProperties(prefix: String = "") = """
 """.trimIndent()
 
 tasks.withType<KotlinCompile> {
-    compilerOptions {
-        freeCompilerArgs.addAll(
-            "-Xjsr305=strict",
-        )
-
-    }
     dependsOn(":executors:jar")
     buildPropertyFile()
 }
@@ -146,7 +134,6 @@ tasks.withType<Test> {
     with(rootProject.kotlinNodeJsEnvSpec) {
         dependsOn(rootProject.nodeJsSetupTaskProvider)
     }
-    useJUnitPlatform()
     javaLauncher.set(javaToolchains.launcherFor {
         languageVersion.set(JavaLanguageVersion.of(17))
         vendor.set(JvmVendorSpec.AMAZON)

buildSrc/settings.gradle.kts

@@ -2,18 +2,7 @@ pluginManagement {
     includeBuild("../build-settings-logic")
 }
 
-dependencyResolutionManagement {
-    // For buildSrc we need to declare a custom path to the toml file with versions' catalog.
-    // But for a root project we can't set `from` inside `versionCatalogs` catalog block for the default `libs` catalog.
-    // (see https://github.com/gradle/gradle/issues/21328)
-    // That is why it is not fully moved to the dependencyResolutionManagement block in the settings convention plugin.
-    versionCatalogs {
-        getByName("libs") {
-            from(files("../gradle/libs.versions.toml"))
-        }
-    }
-}
-
 plugins {
     id("kotlin-compiler-server-version-catalog")
+    id("dev.panuszewski.typesafe-conventions") version "0.9.0"
 }

buildSrc/src/main/kotlin/base-spring-boot-conventions.gradle.kts

@@ -0,0 +1,21 @@
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
+
+plugins {
+    id("base-kotlin-jvm-conventions")
+
+    alias(libs.plugins.spring.boot)
+    alias(libs.plugins.spring.dependency.management)
+    alias(libs.plugins.kotlin.plugin.spring)
+}
+
+dependencies {
+    testImplementation(libs.spring.boot.starter.test) {
+        exclude(group = "org.junit.vintage", module = "junit-vintage-engine")
+    }
+}
+
+tasks.withType<KotlinCompile>().configureEach {
+    compilerOptions { freeCompilerArgs.addAll("-Xjsr305=strict") }
+}
+
+tasks.withType<Test>().configureEach { useJUnitPlatform() }

completions/build.gradle.kts

@@ -0,0 +1,26 @@
+import org.springframework.boot.gradle.tasks.bundling.BootBuildImage
+
+plugins {
+    id("base-spring-boot-conventions")
+}
+
+version = "${libs.versions.kotlin.get()}-SNAPSHOT"
+
+dependencies {
+    implementation(libs.spring.boot.starter.webflux)
+    implementation(libs.spring.boot.docker.compose)
+    implementation(libs.springdoc.webflux)
+    implementation(libs.org.eclipse.lsp4j)
+    implementation(libs.kotlinx.coroutines.reactor)
+    testImplementation(libs.kotlin.test)
+    testImplementation(libs.bundles.testcontainers)
+    testImplementation(libs.rector.test)
+}
+
+tasks.named<BootBuildImage>("bootBuildImage") {
+    // TODO(KTL-3803):push docker image to JB registry
+    val baseImageName = "sfuri/kotlin-compiler-server-completions-lsp"
+    // publish = true
+    imageName = "$baseImageName:${project.version}"
+    tags = setOf("$baseImageName:latest")
+}

completions/build_completions_image.sh

@@ -0,0 +1,17 @@
+#!/bin/bash
+
+export COMPLETIONS_SERVICE_PORT=8081
+
+# export LSP_LOCAL_WORKSPACE_ROOT=lsp-users-projects-root
+export LSP_REMOTE_WORKSPACE_ROOT=lsp-users-projects-root-test
+
+echo "building docker image for spring application"
+yes n | ../gradlew bootBuildImage
+
+if [[ " $* " == *" --run "* ]]; then
+  echo "requested starting completion service"
+  docker compose up -d
+  echo "completion service up and running"
+fi
+
+exit 0

completions/compose.yml

@@ -0,0 +1,23 @@
+services:
+  kotlin-lsp:
+    image: sfuri/intellij-lsp
+    ports:
+      - "9999:9999"
+    networks:
+      - lsp-lsp-net
+
+  lsp-completions-service:
+    image: sfuri/kotlin-compiler-server-completions-lsp
+    ports:
+      - "${COMPLETIONS_SERVICE_PORT}:8082"
+    networks:
+      - lsp-lsp-net
+    environment:
+      - LSP_HOST=kotlin-lsp
+      - LSP_PORT=9999
+    depends_on:
+      - kotlin-lsp
+
+networks:
+  lsp-lsp-net:
+    driver: bridge

completions/src/main/kotlin/completions/CompletionsApplication.kt

@@ -0,0 +1,14 @@
+package completions
+
+import completions.configuration.lsp.LspProperties
+import org.springframework.boot.autoconfigure.SpringBootApplication
+import org.springframework.boot.context.properties.EnableConfigurationProperties
+import org.springframework.boot.runApplication
+
+@SpringBootApplication
+@EnableConfigurationProperties(value = [LspProperties::class])
+class CompletionsApplication
+
+fun main(args: Array<String>) {
+    runApplication<CompletionsApplication>(*args)
+}

completions/src/main/kotlin/completions/configuration/CoroutinesConfig.kt

@@ -0,0 +1,16 @@
+package completions.configuration
+
+import kotlinx.coroutines.asCoroutineDispatcher
+import org.springframework.context.annotation.Bean
+import org.springframework.context.annotation.Configuration
+import java.util.concurrent.Executors
+import kotlin.coroutines.CoroutineContext
+
+@Configuration
+class CoroutinesConfig {
+    @Bean
+    fun lspCoroutineContext(): CoroutineContext {
+        val parallelism = (Runtime.getRuntime().availableProcessors() / 2).coerceAtLeast(4)
+        return Executors.newFixedThreadPool(parallelism).asCoroutineDispatcher()
+    }
+}

completions/src/main/kotlin/completions/configuration/CorsConfiguration.kt

@@ -0,0 +1,18 @@
+package completions.configuration
+
+import org.springframework.context.annotation.Bean
+import org.springframework.context.annotation.Configuration
+import org.springframework.web.cors.CorsConfiguration
+import org.springframework.web.cors.reactive.UrlBasedCorsConfigurationSource
+import org.springframework.web.cors.reactive.CorsWebFilter
+
+@Configuration
+class CorsConfiguration {
+    @Bean
+    fun corsFilter(): CorsWebFilter {
+        val source = UrlBasedCorsConfigurationSource()
+        val config = CorsConfiguration().applyPermitDefaultValues()
+        source.registerCorsConfiguration("/**", config)
+        return CorsWebFilter(source)
+    }
+}

completions/src/main/kotlin/completions/configuration/JacksonConfig.kt

@@ -0,0 +1,14 @@
+package completions.configuration
+
+import com.fasterxml.jackson.databind.ObjectMapper
+import com.fasterxml.jackson.module.kotlin.kotlinModule
+import org.springframework.context.annotation.Bean
+import org.springframework.context.annotation.Configuration
+
+@Configuration
+class JacksonConfig {
+
+    @Bean
+    fun objectMapper(): ObjectMapper =
+        ObjectMapper().registerModule(kotlinModule())
+}

completions/src/main/kotlin/completions/configuration/WebSocketConfiguration.kt

@@ -0,0 +1,22 @@
+package completions.configuration
+
+import completions.controllers.ws.LspCompletionWebSocketHandler
+import org.springframework.context.annotation.Bean
+import org.springframework.context.annotation.Configuration
+import org.springframework.web.reactive.HandlerMapping
+import org.springframework.web.reactive.handler.SimpleUrlHandlerMapping
+import org.springframework.web.reactive.socket.server.support.WebSocketHandlerAdapter
+
+@Configuration
+class WebSocketConfiguration {
+    @Bean
+    fun webSocketHandlerAdapter(): WebSocketHandlerAdapter = WebSocketHandlerAdapter()
+
+    @Bean
+    fun webSocketMapping(handler: LspCompletionWebSocketHandler): HandlerMapping =
+        SimpleUrlHandlerMapping(mapOf(WEBSOCKET_COMPLETIONS_PATH to handler), 1)
+
+    companion object {
+        const val WEBSOCKET_COMPLETIONS_PATH = "/api/complete"
+    }
+}

completions/src/main/kotlin/completions/configuration/lsp/LspProperties.kt

@@ -0,0 +1,16 @@
+package completions.configuration.lsp
+
+import org.springframework.boot.context.properties.ConfigurationProperties
+
+/**
+ * Simple LSP configuration properties which expose a way to be accessed
+ * even from non-spring managed components, i.e. [completions.lsp.client.LspConnectionManager].
+ */
+@ConfigurationProperties(prefix = "lsp")
+data class LspProperties(
+    val host: String,
+    val port: Int,
+    val reconnectionRetries: Int,
+    val remoteWorkspaceRoot: String = "/lsp/workspaces/lsp-users-projects-root",
+    val localWorkspaceRoot: String = "/lsp/workspaces/lsp-users-projects-root"
+)

completions/src/main/kotlin/completions/controllers/rest/CompletionsRestController.kt

@@ -0,0 +1,25 @@
+package completions.controllers.rest
+
+import completions.dto.api.CompletionRequest
+import completions.dto.api.CompletionResponse
+import completions.service.lsp.LspCompletionQueue
+import org.springframework.web.bind.annotation.PostMapping
+import org.springframework.web.bind.annotation.RequestBody
+import org.springframework.web.bind.annotation.RequestMapping
+import org.springframework.web.bind.annotation.RequestParam
+import org.springframework.web.bind.annotation.RestController
+
+@RestController
+@RequestMapping(value = ["/api/compiler"])
+class CompletionsRestController(
+    private val lspCompletionQueue: LspCompletionQueue,
+) {
+    @PostMapping("/complete")
+    suspend fun complete(
+        @RequestBody completionRequest: CompletionRequest,
+        @RequestParam line: Int,
+        @RequestParam ch: Int,
+    ): List<CompletionResponse> {
+        return lspCompletionQueue.complete(completionRequest, line, ch)
+    }
+}