Add compose wasm as independent target

Dockerfile

@@ -10,7 +10,8 @@ RUN if [ -z "$KOTLIN_VERSION" ]; then \
 ENV KOTLIN_LIB=$KOTLIN_VERSION
 ENV KOTLIN_LIB_JS=${KOTLIN_VERSION}-js
 ENV KOTLIN_LIB_WASM=${KOTLIN_VERSION}-wasm
-ENV KOTLIN_COMPILER_PLUGINS=${KOTLIN_VERSION}-compiler-plugins
+ENV KOTLIN_LIB_COMPOSE_WASM=${KOTLIN_VERSION}-compose-wasm
+ENV KOTLIN_COMPOSE_WASM_COMPILER_PLUGINS=${KOTLIN_VERSION}-compose-wasm-compiler-plugins
 
 RUN mkdir -p /kotlin-compiler-server
 WORKDIR /kotlin-compiler-server
@@ -30,7 +31,8 @@ COPY --from=build /build/libs/BOOT-INF/classes /kotlin-compiler-server
 COPY --from=build /kotlin-compiler-server/${KOTLIN_LIB} /kotlin-compiler-server/${KOTLIN_LIB}
 COPY --from=build /kotlin-compiler-server/${KOTLIN_LIB_JS} /kotlin-compiler-server/${KOTLIN_LIB_JS}
 COPY --from=build /kotlin-compiler-server/${KOTLIN_LIB_WASM} /kotlin-compiler-server/${KOTLIN_LIB_WASM}
-COPY --from=build /kotlin-compiler-server/${KOTLIN_COMPILER_PLUGINS} /kotlin-compiler-server/${KOTLIN_COMPILER_PLUGINS}
+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/

build.gradle.kts

@@ -97,10 +97,12 @@ fun generateProperties(prefix: String = "") = """
     indexes.file=${prefix + indexes}
     indexesJs.file=${prefix + indexesJs}
     indexesWasm.file=${prefix + indexesWasm}
+    indexesComposeWasm.file=${prefix + indexesComposeWasm}
     libraries.folder.jvm=${prefix + libJVMFolder}
     libraries.folder.js=${prefix + libJSFolder}
     libraries.folder.wasm=${prefix + libWasmFolder}
-    libraries.folder.compiler-plugins=${prefix + libCompilerPluginsFolder}
+    libraries.folder.compose-wasm=${prefix + libComposeWasmFolder}
+    libraries.folder.compose-wasm-compiler-plugins=${prefix + libComposeWasmCompilerPluginsFolder}
     spring.mvc.pathmatch.matching-strategy=ant_path_matcher
     server.compression.enabled=true
     server.compression.mime-types=application/json
@@ -120,7 +122,8 @@ tasks.withType<KotlinCompile> {
     dependsOn(":dependencies:copyDependencies")
     dependsOn(":dependencies:copyJSDependencies")
     dependsOn(":dependencies:copyWasmDependencies")
-    dependsOn(":dependencies:copyCompilerPlugins")
+    dependsOn(":dependencies:copyComposeWasmDependencies")
+    dependsOn(":dependencies:copyComposeWasmCompilerPlugins")
     dependsOn(":executors:jar")
     dependsOn(":indexation:run")
     buildPropertyFile()
@@ -146,8 +149,9 @@ val buildLambda by tasks.creating(Zip::class) {
     from(indexesWasm)
     from(libJSFolder) { into(libJS) }
     from(libWasmFolder) { into(libWasm) }
+    from(libComposeWasmFolder) { into(libComposeWasm) }
     from(libJVMFolder) { into(libJVM) }
-    from(libCompilerPluginsFolder) { into(libCompilerPlugins) }
+    from(libComposeWasmCompilerPluginsFolder) { into(libComposeWasmCompilerPlugins) }
     into("lib") {
         from(configurations.compileClasspath) { exclude("tomcat-embed-*") }
     }

buildSrc/src/main/kotlin/properties.kt

@@ -7,10 +7,12 @@ val kotlinIdeVersionSuffix: String by System.getProperties()
 val indexes: String by System.getProperties()
 val indexesJs: String by System.getProperties()
 val indexesWasm: String by System.getProperties()
+val indexesComposeWasm: String by System.getProperties()
 
 val libJS = "$kotlinVersion-js"
 val libWasm = "$kotlinVersion-wasm"
-val libCompilerPlugins = "$kotlinVersion-compiler-plugins"
+val libComposeWasm = "$kotlinVersion-compose-wasm"
+val libComposeWasmCompilerPlugins = "$kotlinVersion-compose-wasm-compiler-plugins"
 val libJVM = kotlinVersion
 
 val Project.libJSFolder
@@ -19,8 +21,11 @@ val Project.libJSFolder
 val Project.libWasmFolder
     get() = rootProject.layout.projectDirectory.dir(libWasm)
 
-val Project.libCompilerPluginsFolder
-    get() = rootProject.layout.projectDirectory.dir(libCompilerPlugins)
+val Project.libComposeWasmFolder
+    get() = rootProject.layout.projectDirectory.dir(libComposeWasm)
+
+val Project.libComposeWasmCompilerPluginsFolder
+    get() = rootProject.layout.projectDirectory.dir(libComposeWasmCompilerPlugins)
 
 val Project.libJVMFolder
     get() = rootProject.layout.projectDirectory.dir(libJVM)

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

@@ -10,6 +10,7 @@ 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
@@ -26,8 +27,9 @@ class KotlinEnvironment(
   val classpath: List<File>,
   additionalJsClasspath: List<File>,
   additionalWasmClasspath: List<File>,
-  compilerPlugins: List<File>,
-  compilerPluginsOptions: List<CompilerPluginOption>
+  additionalComposeWasmClasspath: List<File>,
+  composeWasmCompilerPlugins: List<File>,
+  composeWasmCompilerPluginsOptions: List<CompilerPluginOption>
 ) {
   companion object {
     /**
@@ -62,10 +64,13 @@ class KotlinEnvironment(
   val WASM_LIBRARIES = additionalWasmClasspath
     .map { it.absolutePath }
     .filter { isKotlinLibrary(File(it)) }
-  val COMPILER_PLUGINS = compilerPlugins
+  val COMPOSE_WASM_LIBRARIES = additionalComposeWasmClasspath
+    .map { it.absolutePath }
+    .filter { isKotlinLibrary(File(it)) }
+  val COMPOSE_WASM_COMPILER_PLUGINS = composeWasmCompilerPlugins
     .map { it.absolutePath }
 
-  val compilerPluginOptions = compilerPluginsOptions
+  val composeWasmCompilerPluginOptions = composeWasmCompilerPluginsOptions
     .map { "plugin:${it.id}:${it.option}=${it.value}" }
 
   @Synchronized
@@ -87,6 +92,20 @@ class KotlinEnvironment(
     put(JSConfigurationKeys.WASM_ENABLE_ASSERTS, false)
   }
 
+  val composeWasmConfiguration: CompilerConfiguration = configuration.copy().apply {
+    put(CommonConfigurationKeys.MODULE_NAME, "moduleId")
+    put(JSConfigurationKeys.LIBRARIES, COMPOSE_WASM_LIBRARIES)
+    put(JSConfigurationKeys.WASM_ENABLE_ARRAY_RANGE_CHECKS, false)
+    put(JSConfigurationKeys.WASM_ENABLE_ASSERTS, false)
+
+    PluginCliParser.loadPluginsSafe(
+      COMPOSE_WASM_COMPILER_PLUGINS,
+      composeWasmCompilerPluginOptions,
+      emptyList(),
+      this
+    )
+  }
+
   private val environment = KotlinCoreEnvironment.createForProduction(
     parentDisposable = Disposer.newDisposable(),
     configuration = configuration.copy(),

dependencies/build.gradle.kts

@@ -38,7 +38,23 @@ val kotlinWasmDependency: Configuration by configurations.creating {
     }
 }
 
-val compilerPlugins: Configuration by configurations.creating {
+val kotlinComposeWasmDependency: Configuration by configurations.creating {
+    isCanBeResolved = true
+    isCanBeConsumed = false
+
+    attributes {
+        attribute(
+            KotlinPlatformType.attribute,
+            KotlinPlatformType.wasm
+        )
+        attribute(
+            KotlinWasmTargetAttribute.wasmTargetAttribute,
+            KotlinWasmTargetAttribute.js
+        )
+    }
+}
+
+val composeWasmCompilerPlugins: Configuration by configurations.creating {
     isTransitive = false
 }
 
@@ -59,9 +75,14 @@ val copyWasmDependencies by tasks.creating(Copy::class) {
     into(libWasmFolder)
 }
 
-val copyCompilerPlugins by tasks.creating(Copy::class) {
-    from(compilerPlugins)
-    into(libCompilerPluginsFolder)
+val copyComposeWasmDependencies by tasks.creating(Copy::class) {
+    from(kotlinComposeWasmDependency)
+    into(libComposeWasmFolder)
+}
+
+val copyComposeWasmCompilerPlugins by tasks.creating(Copy::class) {
+    from(composeWasmCompilerPlugins)
+    into(libComposeWasmCompilerPluginsFolder)
 }
 
 plugins {
@@ -86,13 +107,14 @@ dependencies {
     kotlinWasmDependency("org.jetbrains.kotlin:kotlin-stdlib-wasm-js:$kotlinVersion")
 
     // compose
-    kotlinWasmDependency("org.jetbrains.compose.runtime:runtime:1.6.0-alpha01")
-    kotlinWasmDependency("org.jetbrains.compose.ui:ui:1.6.0-alpha01")
-    kotlinWasmDependency("org.jetbrains.compose.animation:animation:1.6.0-alpha01")
-    kotlinWasmDependency("org.jetbrains.compose.animation:animation-graphics:1.6.0-alpha01")
-    kotlinWasmDependency("org.jetbrains.compose.foundation:foundation:1.6.0-alpha01")
-    kotlinWasmDependency("org.jetbrains.compose.material:material:1.6.0-alpha01")
-    kotlinWasmDependency("org.jetbrains.compose.components:components-resources:1.6.0-alpha01")
-
-    compilerPlugins("org.jetbrains.compose.compiler:compiler-hosted:1.5.4")
+    kotlinComposeWasmDependency("org.jetbrains.kotlin:kotlin-stdlib-wasm-js:$kotlinVersion")
+    kotlinComposeWasmDependency("org.jetbrains.compose.runtime:runtime:1.6.0")
+    kotlinComposeWasmDependency("org.jetbrains.compose.ui:ui:1.6.0")
+    kotlinComposeWasmDependency("org.jetbrains.compose.animation:animation:1.6.0")
+    kotlinComposeWasmDependency("org.jetbrains.compose.animation:animation-graphics:1.6.0")
+    kotlinComposeWasmDependency("org.jetbrains.compose.foundation:foundation:1.6.0")
+    kotlinComposeWasmDependency("org.jetbrains.compose.material:material:1.6.0")
+    kotlinComposeWasmDependency("org.jetbrains.compose.components:components-resources:1.6.0")
+
+    composeWasmCompilerPlugins("org.jetbrains.compose.compiler:compiler-hosted:1.5.10")
 }

indexation/build.gradle.kts

@@ -21,6 +21,7 @@ tasks.withType<JavaExec> {
         "$rootName${File.separator}$kotlinVersion",
         "$rootName${File.separator}$indexes",
         "$rootName${File.separator}$indexesJs",
-        "$rootName${File.separator}$indexesWasm"
+        "$rootName${File.separator}$indexesWasm",
+        "$rootName${File.separator}$indexesComposeWasm",
     )
 }

indexation/src/main/kotlin/KotlinEnvironmentConfiguration.kt

@@ -12,7 +12,8 @@ class KotlinEnvironmentConfiguration(
     val jvmFile = File(fileName)
     val jsFile = File("$fileName-js")
     val wasmFile = File("$fileName-wasm")
-    val compilerPluginsFile = File("$fileName-compiler-plugins")
+    val composeWasmFile = File("$fileName-compose-wasm")
+    val composeWasmCompilerPluginsFile = File("$fileName-compose-wasm-compiler-plugins")
     val classPath =
       listOfNotNull(jvmFile)
         .flatMap {
@@ -22,13 +23,15 @@ class KotlinEnvironmentConfiguration(
 
     val additionalJsClasspath = jsFile.listFiles()?.toList() ?: emptyList()
     val additionalWasmClasspath = wasmFile.listFiles()?.toList() ?: emptyList()
-    val compilerPlugins = compilerPluginsFile.listFiles()?.toList() ?: emptyList()
+    val additionalComposeWasmClasspath = composeWasmFile.listFiles()?.toList() ?: emptyList()
+    val composeWasmCompilerPlugins = composeWasmCompilerPluginsFile.listFiles()?.toList() ?: emptyList()
 
     KotlinEnvironment(
       classPath,
       additionalJsClasspath,
       additionalWasmClasspath,
-      compilerPlugins,
+      additionalComposeWasmClasspath,
+      composeWasmCompilerPlugins,
       listOf(
         CompilerPluginOption(
           "androidx.compose.compiler.plugins.kotlin",

indexation/src/main/kotlin/Main.kt

@@ -6,23 +6,39 @@ package indexation
  * Third argument is path to output file for js indexes
  */
 fun main(args: Array<String>) {
-  val (version, directory, outputPathJvm, outputPathJs, outputPathWasm) = args
+  val version = args[0]
+  val directory = args[1]
+  val outputPathJvm = args[2]
+  val outputPathJs = args[3]
+  val outputPathWasm = args[4]
+  val outputPathComposeWasm = args[5]
   val kotlinEnvironment = KotlinEnvironmentConfiguration(version, directory).kotlinEnvironment
   JvmIndexationBuilder(kotlinEnvironment = kotlinEnvironment).writeIndexesToFile(outputPathJvm)
 
   WebIndexationBuilder(
     kotlinEnvironment = kotlinEnvironment,
     inputConfiguration = kotlinEnvironment.jsConfiguration,
     libraries = kotlinEnvironment.JS_LIBRARIES,
-    compilerPlugins = false,
+    compilerPlugins = emptyList(),
+    compilerPluginOptions = emptyList(),
     platformConfiguration = kotlinEnvironment.jsConfiguration
   ).writeIndexesToFile(outputPathJs)
 
   WebIndexationBuilder(
     kotlinEnvironment = kotlinEnvironment,
     inputConfiguration = kotlinEnvironment.wasmConfiguration,
     libraries = kotlinEnvironment.WASM_LIBRARIES,
-    compilerPlugins = true,
+    compilerPlugins = emptyList(),
+    compilerPluginOptions = emptyList(),
     platformConfiguration = kotlinEnvironment.wasmConfiguration
   ).writeIndexesToFile(outputPathWasm)
+
+  WebIndexationBuilder(
+    kotlinEnvironment = kotlinEnvironment,
+    inputConfiguration = kotlinEnvironment.composeWasmConfiguration,
+    libraries = kotlinEnvironment.COMPOSE_WASM_LIBRARIES,
+    compilerPlugins = kotlinEnvironment.COMPOSE_WASM_COMPILER_PLUGINS,
+    compilerPluginOptions = kotlinEnvironment.composeWasmCompilerPluginOptions,
+    platformConfiguration = kotlinEnvironment.composeWasmConfiguration
+  ).writeIndexesToFile(outputPathComposeWasm)
 }

indexation/src/main/kotlin/WebIndexationBuilder.kt

@@ -13,7 +13,8 @@ class WebIndexationBuilder(
   private val kotlinEnvironment: KotlinEnvironment,
   inputConfiguration: CompilerConfiguration,
   private val libraries: List<String>,
-  private val compilerPlugins: Boolean,
+  private val compilerPlugins: List<String>,
+  private val compilerPluginOptions: List<String>,
   private val platformConfiguration: CompilerConfiguration
 ): IndexationBuilder() {
 
@@ -23,10 +24,10 @@ class WebIndexationBuilder(
     kotlinEnvironment.environment { coreEnvironment ->
       val project = coreEnvironment.project
 
-      if (compilerPlugins) {
+      if (compilerPlugins.isNotEmpty()) {
         PluginCliParser.loadPluginsSafe(
-          kotlinEnvironment.COMPILER_PLUGINS,
-          kotlinEnvironment.compilerPluginOptions,
+          compilerPlugins,
+          compilerPluginOptions,
           emptyList(),
           configuration
         )

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

@@ -204,7 +204,8 @@ class CompletionProvider(
     val analysis = when {
       projectType.isJvmRelated() -> errorAnalyzer.analysisOf(files, coreEnvironment)
       projectType.isJsRelated() -> errorAnalyzer.analyzeFileForJs(files, coreEnvironment)
-      projectType.isWasmRelated() -> errorAnalyzer.analyzeFileForWasm(files, coreEnvironment)
+      projectType == ProjectType.WASM -> errorAnalyzer.analyzeFileForWasm(files, coreEnvironment)
+      projectType == ProjectType.COMPOSE_WASM -> errorAnalyzer.analyzeFileForComposeWasm(files, coreEnvironment)
       else -> throw IllegalArgumentException("Unknown project type $projectType")
     }
     return with(analysis) {