KTL-2973 Deprecated old compilation endpoint.

.github/dependabot.yml

@@ -11,11 +11,8 @@ updates:
       - dependency-name: "org.jetbrains.kotlin:kotlin-compiler"
       - dependency-name: "org.jetbrains.kotlin:kotlin-reflect"
       - dependency-name: "org.jetbrains.kotlin:kotlin-stdlib-js"
-      - dependency-name: "org.jetbrains.kotlin:kotlin-compiler-for-ide"
       - dependency-name: "org.jetbrains.kotlin:kotlin-stdlib"
       - dependency-name: "org.jetbrains.kotlin:kotlin-script-runtime"
-      - dependency-name: "org.jetbrains.kotlin:ide"
-      - dependency-name: "org.jetbrains.kotlin:idea"
       - dependency-name: "org.jetbrains.kotlin:kotlin-test"
       - dependency-name: "org.jetbrains.kotlin:core"
       - dependency-name: "org.jetbrains.kotlin:common"

Dockerfile

@@ -36,10 +36,6 @@ COPY --from=build /kotlin-compiler-server/${KOTLIN_LIB_WASM} /kotlin-compiler-se
 COPY --from=build /kotlin-compiler-server/${KOTLIN_LIB_COMPOSE_WASM} /kotlin-compiler-server/${KOTLIN_LIB_COMPOSE_WASM}
 COPY --from=build /kotlin-compiler-server/${KOTLIN_COMPOSE_WASM_COMPILER_PLUGINS} /kotlin-compiler-server/${KOTLIN_COMPOSE_WASM_COMPILER_PLUGINS}
 COPY --from=build /kotlin-compiler-server/executor.policy /kotlin-compiler-server/
-COPY --from=build /kotlin-compiler-server/indexes.json /kotlin-compiler-server/
-COPY --from=build /kotlin-compiler-server/indexesJs.json /kotlin-compiler-server/
-COPY --from=build /kotlin-compiler-server/indexesWasm.json /kotlin-compiler-server/
-COPY --from=build /kotlin-compiler-server/indexesComposeWasm.json /kotlin-compiler-server/
 
 ENV PORT=8080
 

build-settings-logic/src/main/kotlin/kotlin-compiler-server-version-catalog.settings.gradle.kts

@@ -2,7 +2,6 @@ pluginManagement {
     repositories {
         gradlePluginPortal()
         mavenCentral()
-        mavenLocal()
 
         val additionalRepositoryProperty = providers.gradleProperty("kotlin_repo_url")
         if (additionalRepositoryProperty.isPresent) {
@@ -11,9 +10,8 @@ pluginManagement {
             }
             logger.info("A custom Kotlin repository ${additionalRepositoryProperty.get()} was added")
         }
-
-        maven("https://maven.pkg.jetbrains.space/kotlin/p/kotlin/bootstrap")
         maven("https://redirector.kotlinlang.org/maven/dev")
+        mavenLocal()
     }
 }
 
@@ -22,7 +20,6 @@ dependencyResolutionManagement {
     repositories {
         mavenCentral()
         gradlePluginPortal()
-        mavenLocal()
 
         val additionalRepositoryProperty = providers.gradleProperty("kotlin_repo_url")
         if (additionalRepositoryProperty.isPresent) {
@@ -31,18 +28,8 @@ dependencyResolutionManagement {
             }
             logger.info("A custom Kotlin repository ${additionalRepositoryProperty.get()} was added")
         }
-
-        maven("https://repo.spring.io/snapshot")
-        maven("https://repo.spring.io/milestone")
-        maven("https://redirector.kotlinlang.org/maven/kotlin-ide")
         maven("https://redirector.kotlinlang.org/maven/dev")
-        maven("https://cache-redirector.jetbrains.com/jetbrains.bintray.com/intellij-third-party-dependencies")
-        maven("https://maven.pkg.jetbrains.space/kotlin/p/kotlin/kotlin-ide-plugin-dependencies")
-        maven("https://www.myget.org/F/rd-snapshots/maven/")
-        maven("https://redirector.kotlinlang.org/maven/kotlin-ide")
-        maven("https://maven.pkg.jetbrains.space/kotlin/p/kotlin/bootstrap")
-        maven("https://maven.pkg.jetbrains.space/kotlin/p/wasm/experimental")
-        maven("https://maven.pkg.jetbrains.space/public/p/compose/dev")
+        mavenLocal()
     }
 
     versionCatalogs {

build.gradle.kts

@@ -12,8 +12,8 @@ version = "${libs.versions.kotlin.get()}-SNAPSHOT"
 val propertyFile = "application.properties"
 
 plugins {
-    alias(libs.plugins.spring.dependency.management)
     alias(libs.plugins.spring.boot)
+    alias(libs.plugins.spring.dependency.management)
     alias(libs.plugins.kotlin.plugin.spring)
     id("base-kotlin-jvm-conventions")
 }
@@ -25,9 +25,6 @@ allprojects {
         dependencies {
             dependencies {
                 implementation(libs.jackson.module.kotlin)
-                implementation(libs.kotlin.idea) {
-                    isTransitive = false
-                }
             }
         }
     }
@@ -39,24 +36,24 @@ val resourceDependency: Configuration by configurations.creating {
 }
 
 dependencies {
-    annotationProcessor("org.springframework:spring-context-indexer")
-    implementation("com.google.code.gson:gson")
+    annotationProcessor(libs.spring.context.indexer)
     implementation("org.springframework.boot:spring-boot-starter-web")
-    implementation(libs.springdoc)
+    implementation("org.springframework.boot:spring-boot-starter-validation")
     implementation(libs.aws.springboot.container)
+    implementation(libs.springdoc)
+    implementation(libs.gson)
+    implementation(libs.kotlinx.serialization.json)
+    implementation(libs.kotlin.compiler.arguments.description)
+    implementation(libs.kotlin.tooling.core)
     implementation(libs.junit)
     implementation(libs.logback.logstash.encoder)
-    implementation(libs.intellij.trove4j)
     implementation(libs.kotlin.reflect)
-    implementation(libs.bundles.kotlin.stdlib)
+    implementation(libs.kotlin.stdlib)
     implementation(libs.kotlin.compiler)
     implementation(libs.kotlin.script.runtime)
-    implementation(libs.kotlin.compiler.ide) {
-        isTransitive = false
-    }
-    implementation(libs.kotlin.core)
     implementation(project(":executors", configuration = "default"))
     implementation(project(":common", configuration = "default"))
+    implementation(project(":dependencies"))
 
     testImplementation(libs.kotlin.test)
     testImplementation("org.springframework.boot:spring-boot-starter-test") {
@@ -77,12 +74,10 @@ fun buildPropertyFile() {
 
 fun generateProperties(prefix: String = "") = """
     # this file is autogenerated by build.gradle.kts
+    server.error.include-message=always
+    server.error.include-binding-errors=always
     kotlin.version=${kotlinVersion}
     policy.file=${prefix + policy}
-    indexes.file=${prefix + indexes}
-    indexesJs.file=${prefix + indexesJs}
-    indexesWasm.file=${prefix + indexesWasm}
-    indexesComposeWasm.file=${prefix + indexesComposeWasm}
     libraries.folder.jvm=${prefix + libJVM}
     libraries.folder.js=${prefix + libJS}
     libraries.folder.wasm=${prefix + libWasm}
@@ -97,10 +92,12 @@ fun generateProperties(prefix: String = "") = """
 
 tasks.withType<KotlinCompile> {
     compilerOptions {
-        freeCompilerArgs.set(listOf("-Xjsr305=strict"))
+        freeCompilerArgs.addAll(
+            "-Xjsr305=strict",
+        )
+
     }
     dependsOn(":executors:jar")
-    dependsOn(":indexation:run")
     buildPropertyFile()
 }
 println("Using Kotlin compiler ${libs.versions.kotlin.get()}")
@@ -123,15 +120,11 @@ val buildLambda by tasks.creating(Zip::class) {
         }
     }
     from(policy)
-    from(indexes)
-    from(indexesJs)
-    from(indexesWasm)
-    from(indexesComposeWasm)
     from(libJSFolder) { into(libJS) }
     from(libWasmFolder) { into(libWasm) }
     from(libComposeWasmFolder) { into(libComposeWasm) }
     from(libJVMFolder) { into(libJVM) }
-    from(compilerPluginsForJVMFolder) {into(compilerPluginsForJVM)}
+    from(compilerPluginsForJVMFolder) { into(compilerPluginsForJVM) }
     from(libComposeWasmCompilerPluginsFolder) { into(libComposeWasmCompilerPlugins) }
     into("lib") {
         from(configurations.compileClasspath) { exclude("tomcat-embed-*") }
@@ -160,4 +153,13 @@ tasks.withType<Test> {
     doFirst {
         this@withType.environment("kotlin.wasm.node.path", executablePath)
     }
+
+    // We disable this on TeamCity, because we don't want to fail this test,
+    // when compiler server's test run as a K2 user project.
+    // But for our pull requests we still need to run this test, so we add it to our GitHub action.
+    if (System.getenv("TEAMCITY_VERSION") != null) {
+        filter {
+            excludeTestsMatching("com.compiler.server.CompilerArguments*")
+        }
+    }
 }

buildSrc/src/main/kotlin/base-kotlin-jvm-conventions.gradle.kts

@@ -33,11 +33,11 @@ tasks.withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile>().configureEach
         freeCompilerArgs.addAll(
             "-Xreport-all-warnings",
             "-Xrender-internal-diagnostic-names",
-            "-Xuse-fir-experimental-checkers"
+            "-Xuse-fir-experimental-checkers",
+            "-Xannotation-default-target=param-property"
         )
 
         allWarningsAsErrors.set(false)
-        extraWarnings.set(true)
 
         // Adding additional cli options for testing purpose
         project.providers.gradleProperty("kotlin_additional_cli_options").orNull?.let { options ->

common/build.gradle.kts

@@ -4,6 +4,4 @@ plugins {
 
 dependencies {
     implementation(libs.kotlin.compiler)
-    implementation(libs.kotlin.gradle.plugin.idea)
-    implementation(libs.kotlin.base.fe10.analysis)
 }

common/src/main/kotlin/component/KotlinEnvironment.kt

@@ -1,27 +1,6 @@
 package component
 
-import com.intellij.openapi.util.Disposer
-import org.jetbrains.kotlin.cli.common.arguments.K2JVMCompilerArguments
-import org.jetbrains.kotlin.cli.common.arguments.parseCommandLineArguments
-import org.jetbrains.kotlin.cli.common.arguments.toLanguageVersionSettings
-import org.jetbrains.kotlin.cli.common.messages.MessageCollector
-import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
-import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
-import org.jetbrains.kotlin.cli.jvm.config.addJvmClasspathRoots
-import org.jetbrains.kotlin.cli.jvm.config.configureJdkClasspathRoots
-import org.jetbrains.kotlin.cli.jvm.configureAdvancedJvmOptions
-import org.jetbrains.kotlin.cli.jvm.plugins.PluginCliParser
-import org.jetbrains.kotlin.config.CommonConfigurationKeys
-import org.jetbrains.kotlin.config.CompilerConfiguration
-import org.jetbrains.kotlin.config.JVMConfigurationKeys
-import org.jetbrains.kotlin.config.languageVersionSettings
-import org.jetbrains.kotlin.js.config.JSConfigurationKeys
 import org.jetbrains.kotlin.library.impl.isKotlinLibrary
-import org.jetbrains.kotlin.serialization.js.JsModuleDescriptor
-import org.jetbrains.kotlin.serialization.js.KotlinJavascriptSerializationUtil
-import org.jetbrains.kotlin.serialization.js.ModuleKind
-import org.jetbrains.kotlin.utils.KotlinJavascriptMetadataUtils
-import org.jetbrains.kotlin.wasm.config.WasmConfigurationKeys
 import java.io.File
 
 // NOTE: if new class paths are added, please add them to `JavaExec` task's inputs in build.gradle.kts as well
@@ -56,18 +35,10 @@ class KotlinEnvironment(
       "-Xnested-type-aliases",
       "-Xreport-all-warnings",
       "-Wextra",
-      "-XXLanguage:+ExplicitBackingFields",
+      "-Xexplicit-backing-fields",
     )
   }
 
-  val JS_METADATA_CACHE =
-    additionalJsClasspath.flatMap {
-      KotlinJavascriptMetadataUtils.loadMetadata(it.absolutePath).map { metadata ->
-        val parts = KotlinJavascriptSerializationUtil.readModuleAsProto(metadata.body, metadata.version)
-        JsModuleDescriptor(metadata.moduleName, parts.kind, parts.importedModules, parts)
-      }
-    }
-
   val JS_LIBRARIES = additionalJsClasspath
     .map { it.absolutePath }
     .filter { isKotlinLibrary(File(it)) }
@@ -83,70 +54,9 @@ class KotlinEnvironment(
   val composeWasmCompilerPluginOptions = composeWasmCompilerPluginsOptions
     .map { "plugin:${it.id}:${it.option}=${it.value}" }
 
-  @Synchronized
-  fun <T> environment(f: (KotlinCoreEnvironment) -> T): T {
-    return f(environment)
-  }
-
-  private val configuration = createConfiguration()
-  val jsConfiguration: CompilerConfiguration = configuration.copy().apply {
-    put(CommonConfigurationKeys.MODULE_NAME, "playground")
-    put(JSConfigurationKeys.MODULE_KIND, ModuleKind.PLAIN)
-    put(JSConfigurationKeys.LIBRARIES, JS_LIBRARIES)
-  }
-
-  val wasmConfiguration: CompilerConfiguration = configuration.copy().apply {
-    put(CommonConfigurationKeys.MODULE_NAME, "playground")
-    put(JSConfigurationKeys.LIBRARIES, WASM_LIBRARIES)
-    put(WasmConfigurationKeys.WASM_ENABLE_ARRAY_RANGE_CHECKS, false)
-    put(WasmConfigurationKeys.WASM_ENABLE_ASSERTS, false)
-  }
-
-  val rootDisposable = Disposer.newDisposable()
-
-  val composeWasmConfiguration: CompilerConfiguration = configuration.copy().apply {
-    put(CommonConfigurationKeys.MODULE_NAME, "playground")
-    put(JSConfigurationKeys.LIBRARIES, COMPOSE_WASM_LIBRARIES)
-    put(WasmConfigurationKeys.WASM_ENABLE_ARRAY_RANGE_CHECKS, false)
-    put(WasmConfigurationKeys.WASM_ENABLE_ASSERTS, false)
-
-    PluginCliParser.loadPluginsSafe(
-      COMPOSE_WASM_COMPILER_PLUGINS,
-      composeWasmCompilerPluginOptions,
-      emptyList<String>(),
-      this,
-      rootDisposable
-    )
-  }
-
-  private val environment = KotlinCoreEnvironment.createForProduction(
-    projectDisposable = rootDisposable,
-    configuration = configuration.copy(),
-    configFiles = EnvironmentConfigFiles.JVM_CONFIG_FILES
-  )
-
-  private fun createConfiguration(): CompilerConfiguration {
-    val arguments = K2JVMCompilerArguments()
-    parseCommandLineArguments(additionalCompilerArguments, arguments)
-    return CompilerConfiguration().apply {
-      addJvmClasspathRoots(classpath.filter { it.exists() && it.isFile && it.extension == "jar" })
-      val messageCollector = MessageCollector.NONE
-      put(CommonConfigurationKeys.MESSAGE_COLLECTOR_KEY, messageCollector)
-      put(CommonConfigurationKeys.MODULE_NAME, "web-module")
-      put(JSConfigurationKeys.PROPERTY_LAZY_INITIALIZATION, true)
-
-      languageVersionSettings = arguments.toLanguageVersionSettings(messageCollector)
-
-      // it uses languageVersionSettings that was set above
-      configureAdvancedJvmOptions(arguments)
-      put(JVMConfigurationKeys.DO_NOT_CLEAR_BINDING_CONTEXT, true)
-
-      configureJdkClasspathRoots()
-      val jdkHome = get(JVMConfigurationKeys.JDK_HOME)
-      if (jdkHome == null) {
-        val javaHome = File(System.getProperty("java.home"))
-        put(JVMConfigurationKeys.JDK_HOME, javaHome)
-      }
+    @Synchronized
+    fun <T> synchronize(f: () -> T): T {
+        return f()
     }
-  }
+
 }

dependencies/build.gradle.kts

@@ -68,8 +68,6 @@ val composeWasmCompilerPlugins: Configuration by configurations.creating {
     isTransitive = false
 }
 
-val composeRuntimeVersion = "1.6.0"
-
 val copyDependencies by tasks.creating(Copy::class) {
     from(kotlinDependency)
     into(libJVMFolder)
@@ -105,7 +103,7 @@ dependencies {
     kotlinDependency(libs.hamcrest)
     kotlinDependency(libs.bundles.jackson)
     // Kotlin libraries
-    kotlinDependency(libs.bundles.kotlin.stdlib)
+    kotlinDependency(libs.kotlin.stdlib)
     kotlinDependency(libs.kotlin.test)
     kotlinDependency(libs.kotlin.test.junit)
     kotlinDependency(libs.kotlinx.coroutines.core.jvm)
@@ -125,4 +123,13 @@ dependencies {
     kotlinComposeWasmDependency(libs.bundles.compose)
 
     composeWasmCompilerPlugins(libs.kotlin.compose.compiler.plugin)
+}
+
+project.tasks.jar.configure {
+    dependsOn(copyDependencies)
+    dependsOn(copyCompilerPluginDependencies)
+    dependsOn(copyJSDependencies)
+    dependsOn(copyWasmDependencies)
+    dependsOn(copyComposeWasmDependencies)
+    dependsOn(copyComposeWasmCompilerPlugins)
 }

gradle.properties

@@ -1,7 +1,3 @@
 systemProp.policy=executor.policy
-systemProp.indexes=indexes.json
-systemProp.indexesJs=indexesJs.json
-systemProp.indexesWasm=indexesWasm.json
-systemProp.indexesComposeWasm=indexesComposeWasm.json
 
 org.gradle.configuration-cache=true