Add IC for Compose Wasm

Author: ilgonmic

build.gradle.kts

@@ -41,9 +41,17 @@ allprojects {
         maven("https://maven.pkg.jetbrains.space/kotlin/p/wasm/experimental")
         maven("https://maven.pkg.jetbrains.space/public/p/compose/dev")
     }
-    afterEvaluate {
-        dependencies {
-            dependencies {
+}
+
+setOf(
+    rootProject,
+    project(":common"),
+    project(":executors"),
+    project(":indexation"),
+).forEach { project ->
+    project.afterEvaluate {
+        project.dependencies {
+            project.dependencies {
                 implementation("com.fasterxml.jackson.module:jackson-module-kotlin:2.15.2")
                 implementation(libs.kotlin.idea) {
                     isTransitive = false
@@ -109,6 +117,7 @@ fun generateProperties(prefix: String = "") = """
     libraries.folder.compose-wasm=${prefix + libComposeWasm}
     libraries.folder.compose-wasm-compiler-plugins=${prefix + libComposeWasmCompilerPlugins}
     libraries.folder.compiler-plugins=${prefix + compilerPluginsForJVM}
+    caches.folder.compose-wasm=${prefix + cachesComposeWasm}
     spring.mvc.pathmatch.matching-strategy=ant_path_matcher
     server.compression.enabled=true
     server.compression.mime-types=application/json,text/javascript,application/wasm

buildSrc/src/main/kotlin/properties.kt

@@ -1,6 +1,6 @@
+import org.gradle.accessors.dm.LibrariesForLibs
 import org.gradle.api.Project
 import org.gradle.kotlin.dsl.provideDelegate
-import org.gradle.accessors.dm.LibrariesForLibs
 import org.gradle.kotlin.dsl.the
 
 val indexes: String by System.getProperties()
@@ -25,6 +25,8 @@ val Project.libComposeWasm
     get() = "$kotlinVersion-compose-wasm"
 val Project.libComposeWasmCompilerPlugins
     get() = "$kotlinVersion-compose-wasm-compiler-plugins"
+val Project.cachesComposeWasm
+    get() = "$kotlinVersion-caches-compose-wasm"
 
 val Project.libJVMFolder
     get() = rootProject.layout.projectDirectory.dir(libJVM)
@@ -42,4 +44,7 @@ val Project.libComposeWasmFolder
     get() = rootProject.layout.projectDirectory.dir(libComposeWasm)
 
 val Project.libComposeWasmCompilerPluginsFolder
-    get() = rootProject.layout.projectDirectory.dir(libComposeWasmCompilerPlugins)
+    get() = rootProject.layout.projectDirectory.dir(libComposeWasmCompilerPlugins)
+
+val Project.cachesComposeWasmFolder
+    get() = rootProject.layout.projectDirectory.dir(cachesComposeWasm)

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

@@ -1,7 +1,6 @@
 package component
 
 import com.intellij.openapi.util.Disposer
-import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
 import org.jetbrains.kotlin.cli.common.arguments.K2JVMCompilerArguments
 import org.jetbrains.kotlin.cli.common.arguments.parseCommandLineArguments
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector
@@ -33,6 +32,7 @@ class KotlinEnvironment(
   composeWasmCompilerPlugins: List<File>,
   val compilerPlugins: List<File> = emptyList(),
   composeWasmCompilerPluginsOptions: List<CompilerPluginOption>,
+  val composeWasmCache: File,
 ) {
   companion object {
     /**

gradle/libs.versions.toml

@@ -14,11 +14,11 @@ kotlinx-coroutines-test = "1.6.4"
 kotlinx-datetime = "0.6.0-RC.2"
 kotlinx-io = "0.5.3"
 kotlinx-serialization = "1.7.1"
-skiko = "0.7.90"
+skiko = "0.8.15"
 # don't forget to update jackson version in `executor.policy` file.
 jackson = "2.14.0"
 hamcrest = "2.2"
-compose = "1.6.0"
+compose = "1.7.0-rc01"
 
 [libraries]
 kotlin-reflect = { group = "org.jetbrains.kotlin", name = "kotlin-reflect", version.ref = "kotlin" }

indexation/src/main/kotlin/KotlinEnvironmentConfiguration.kt

@@ -14,6 +14,7 @@ class KotlinEnvironmentConfiguration(
     val wasmFile = File("$fileName-wasm")
     val composeWasmFile = File("$fileName-compose-wasm")
     val composeWasmCompilerPluginsFile = File("$fileName-compose-wasm-compiler-plugins")
+    val composeWasmCachesFile = File("$fileName-caches-compose-wasm")
     val classPath =
       listOfNotNull(jvmFile)
         .flatMap {
@@ -44,7 +45,8 @@ class KotlinEnvironmentConfiguration(
           "suppressKotlinVersionCompatibilityCheck",
           version
         ),
-      )
+      ),
+      composeWasmCachesFile
     )
   }
 }

src/main/kotlin/com/compiler/server/compiler/components/KotlinEnvironment.kt

@@ -1,15 +1,16 @@
 package com.compiler.server.compiler.components
 
+import com.compiler.server.model.bean.CachesFile
 import com.compiler.server.model.bean.LibrariesFile
-import com.compiler.server.model.bean.VersionInfo
 import component.CompilerPluginOption
 import component.KotlinEnvironment
 import org.springframework.context.annotation.Bean
 import org.springframework.context.annotation.Configuration
 
 @Configuration
 class KotlinEnvironmentConfiguration(
-  val librariesFile: LibrariesFile
+  val librariesFile: LibrariesFile,
+  val cachesFile: CachesFile,
 ) {
   @Bean
   fun kotlinEnvironment(): KotlinEnvironment {
@@ -39,7 +40,8 @@ class KotlinEnvironmentConfiguration(
           "generateDecoys",
           "false"
         ),
-      )
+      ),
+      cachesFile.composeWasm
     )
   }
 }

src/main/kotlin/com/compiler/server/compiler/components/KotlinToJSTranslator.kt

@@ -6,9 +6,11 @@ import component.KotlinEnvironment
 import org.jetbrains.kotlin.cli.js.K2JSCompiler
 import org.jetbrains.kotlin.psi.KtFile
 import org.springframework.stereotype.Service
-import kotlin.io.path.div
-import kotlin.io.path.readBytes
-import kotlin.io.path.readText
+import java.io.File
+import java.nio.file.Path
+import kotlin.contracts.ExperimentalContracts
+import kotlin.contracts.contract
+import kotlin.io.path.*
 
 @Service
 class KotlinToJSTranslator(
@@ -46,28 +48,42 @@ class KotlinToJSTranslator(
   fun translateWasm(
     files: List<KtFile>,
     debugInfo: Boolean,
+    generateIncrementalCache: Boolean,
     projectType: ProjectType,
-    translate: (List<KtFile>, List<String>, List<String>, List<String>) -> CompilationResult<WasmTranslationSuccessfulOutput>
+    translate: (
+      List<KtFile>,
+      List<String>,
+      List<String>,
+      List<String>,
+      Boolean,
+      File?,
+      Boolean,
+    ) -> CompilationResult<WasmTranslationSuccessfulOutput>
   ): TranslationResultWithJsCode {
     return try {
-      val (dependencies, compilerPlugins, compilerPluginOptions) = when (projectType) {
-        ProjectType.WASM -> listOf(
+      val parameters: WasmParameters = when (projectType) {
+        ProjectType.WASM -> WasmParameters(
           kotlinEnvironment.WASM_LIBRARIES,
           emptyList(),
-          emptyList()
+          emptyList(),
+          null
         )
-        ProjectType.COMPOSE_WASM -> listOf(
+        ProjectType.COMPOSE_WASM -> WasmParameters(
           kotlinEnvironment.COMPOSE_WASM_LIBRARIES,
           kotlinEnvironment.COMPOSE_WASM_COMPILER_PLUGINS,
-          kotlinEnvironment.composeWasmCompilerPluginOptions
+          kotlinEnvironment.composeWasmCompilerPluginOptions,
+          kotlinEnvironment.composeWasmCache,
         )
         else -> throw IllegalStateException("Wasm should have wasm or compose-wasm project type")
       }
       val compilationResult = translate(
         files,
-        dependencies,
-        compilerPlugins,
-        compilerPluginOptions
+        parameters.dependencies,
+        parameters.plugins,
+        parameters.pluginOptions,
+        generateIncrementalCache,
+        parameters.cacheDir,
+        debugInfo,
       )
       val wasmCompilationOutput = when (compilationResult) {
         is Compiled<WasmTranslationSuccessfulOutput> -> compilationResult.result
@@ -136,6 +152,9 @@ class KotlinToJSTranslator(
     dependencies: List<String>,
     compilerPlugins: List<String>,
     compilerPluginOptions: List<String>,
+    generateIncrementalCache: Boolean,
+    cacheDir: File?,
+    debugInfo: Boolean,
   ): CompilationResult<WasmTranslationSuccessfulOutput> =
     usingTempDirectory { inputDir ->
       val moduleName = "moduleId"
@@ -156,40 +175,71 @@ class KotlinToJSTranslator(
           val additionalCompilerArgumentsForKLib: List<String> = listOf(
             "-Xreport-all-warnings",
             "-Wextra",
-          "-Xwasm",
-          "-Xir-produce-klib-dir",
-          "-libraries=${dependencies.joinToString(PATH_SEPARATOR)}",
-          "-ir-output-dir=$klibPath",
-          "-ir-output-name=$moduleName",
-        ) + compilerPluginsArgs
+            "-Xwasm",
+            "-Xir-produce-klib-dir",
+            "-libraries=${dependencies.joinToString(PATH_SEPARATOR)}",
+            "-ir-output-dir=$klibPath",
+            "-ir-output-name=$moduleName",
+          ) + compilerPluginsArgs
 
-        k2JSCompiler.tryCompilation(inputDir, ioFiles, filePaths + additionalCompilerArgumentsForKLib)
-          .flatMap {
-            k2JSCompiler.tryCompilation(inputDir, ioFiles, listOf(
-              "-Xreport-all-warnings",
-              "-Wextra",
-              "-Xwasm",
-              "-Xwasm-generate-wat",
-              "-Xir-produce-js",
-              "-Xir-dce",
-              "-Xinclude=$klibPath",
-              "-libraries=${dependencies.joinToString(PATH_SEPARATOR)}",
-              "-ir-output-dir=${(outputDir / "wasm").toFile().canonicalPath}",
-              "-ir-output-name=$moduleName",
-            ))
-          }
-          .map {
-            WasmTranslationSuccessfulOutput(
-              jsCode = (outputDir / "wasm" / "$moduleName.uninstantiated.mjs").readText(),
-              jsInstantiated = (outputDir / "wasm" / "$moduleName.mjs").readText(),
-              wasm = (outputDir / "wasm" / "$moduleName.wasm").readBytes(),
-              wat = (outputDir / "wasm" / "$moduleName.wat").readText(),
-            )
+        val compileAction: (icDir: Path?) -> CompilationResult<WasmTranslationSuccessfulOutput> = { icDir ->
+          k2JSCompiler.tryCompilation(inputDir, ioFiles, filePaths + additionalCompilerArgumentsForKLib)
+            .flatMap {
+              k2JSCompiler.tryCompilation(
+                inputDir, ioFiles, mutableListOf(
+                  "-Xreport-all-warnings",
+                  "-Wextra",
+                  "-Xwasm",
+                  "-Xir-produce-js",
+                  "-Xinclude=$klibPath",
+                  "-libraries=${dependencies.joinToString(PATH_SEPARATOR)}",
+                  "-ir-output-dir=${(outputDir / "wasm").toFile().canonicalPath}",
+                  "-ir-output-name=$moduleName",).also {
+                    if (debugInfo) it.add("-Xwasm-generate-wat")
+                    if (compileWithCacheDir(generateIncrementalCache, icDir)) {
+                      it.add("-Xcache-directory=${icDir.normalize().absolutePathString()}")
+                    } else {
+                      it.add("-Xir-dce")
+                    }
+                  }
+              )
+            }
+            .map {
+              WasmTranslationSuccessfulOutput(
+                jsCode = (outputDir / "wasm" / "$moduleName.uninstantiated.mjs").readText(),
+                jsInstantiated = (outputDir / "wasm" / "$moduleName.mjs").readText(),
+                wasm = (outputDir / "wasm" / "$moduleName.wasm").readBytes(),
+                wat = if (debugInfo) (outputDir / "wasm" / "$moduleName.wat").readText() else null,
+              )
+            }
+        }
+
+        if (generateIncrementalCache) {
+          compileAction(cacheDir!!.toPath())
+        } else {
+          val cacheDirPath = cacheDir?.toPath()
+          if (compileWithCacheDir(generateIncrementalCache = false, cacheDirPath)) {
+            usingTempDirectory { tmpDir ->
+              val cachesDir = tmpDir.resolve("caches").normalize()
+              cacheDirPath.toFile().copyRecursively(cachesDir.toFile())
+              compileAction(cachesDir)
+            }
+          } else {
+            compileAction(null)
           }
+        }
       }
     }
 }
 
+@OptIn(ExperimentalContracts::class)
+private fun compileWithCacheDir(generateIncrementalCache: Boolean, cacheDir: Path?): Boolean {
+  contract {
+    returns() implies (cacheDir != null)
+  }
+  return cacheDir != null && (generateIncrementalCache || cacheDir.exists())
+}
+
 private fun String.withMainArgumentsIr(arguments: List<String>): String {
   val mainIrFunction = """
     |  function mainWrapper() {

src/main/kotlin/com/compiler/server/compiler/components/WasmParameters.kt

@@ -0,0 +1,10 @@
+package com.compiler.server.compiler.components
+
+import java.io.File
+
+data class WasmParameters(
+    val dependencies: List<String>,
+    val plugins: List<String>,
+    val pluginOptions: List<String>,
+    val cacheDir: File?
+)

src/main/kotlin/com/compiler/server/configuration/ApplicationConfiguration.kt

@@ -1,5 +1,6 @@
 package com.compiler.server.configuration
 
+import com.compiler.server.model.bean.CachesFile
 import com.compiler.server.model.bean.LibrariesFile
 import com.compiler.server.model.bean.VersionInfo
 import org.springframework.beans.factory.annotation.Value
@@ -12,10 +13,11 @@ import org.springframework.web.servlet.config.annotation.WebMvcConfigurer
 import java.io.File
 
 @Configuration
-@EnableConfigurationProperties(value = [LibrariesFolderProperties::class])
+@EnableConfigurationProperties(value = [LibrariesFolderProperties::class, CachesFolderProperties::class])
 class ApplicationConfiguration(
   @Value("\${kotlin.version}") private val version: String,
-  private val librariesFolderProperties: LibrariesFolderProperties
+  private val librariesFolderProperties: LibrariesFolderProperties,
+  private val cachesFolderProperties: CachesFolderProperties,
 ) : WebMvcConfigurer {
   override fun addFormatters(registry: FormatterRegistry) {
     registry.addConverter(ProjectConverter())
@@ -36,6 +38,11 @@ class ApplicationConfiguration(
     File(librariesFolderProperties.composeWasmCompilerPlugins),
     File(librariesFolderProperties.compilerPlugins)
   )
+
+  @Bean
+  fun cachesFiles() = CachesFile(
+    File(cachesFolderProperties.composeWasm)
+  )
 }
 
 @ConfigurationProperties(prefix = "libraries.folder")
@@ -46,4 +53,9 @@ class LibrariesFolderProperties {
   lateinit var composeWasm: String
   lateinit var composeWasmCompilerPlugins: String
   lateinit var compilerPlugins: String
+}
+
+@ConfigurationProperties(prefix = "caches.folder")
+class CachesFolderProperties {
+  lateinit var composeWasm: String
 }

src/main/kotlin/com/compiler/server/controllers/CompilerRestController.kt

@@ -37,6 +37,16 @@ class CompilerRestController(private val kotlinProjectExecutor: KotlinProjectExe
     }
   }
 
+  @PostMapping("/generate-cache")
+  fun generateKotlinIncrementalCacheEndpoint(
+    @RequestParam(defaultValue = "compose-wasm") compiler: String
+  ): TranslationResultWithJsCode? {
+    return when (KotlinTranslatableCompiler.valueOf(compiler.uppercase().replace("-", "_"))) {
+      KotlinTranslatableCompiler.COMPOSE_WASM -> kotlinProjectExecutor.generateWasmIncrementalCache(ProjectType.COMPOSE_WASM)
+      else -> null
+    }
+  }
+
   @PostMapping("/complete")
   fun getKotlinCompleteEndpoint(
     @RequestBody project: Project,