Add IC for Compose Wasm

.gitignore

@@ -4,6 +4,7 @@ build/
 !**/src/main/**
 !**/src/test/**
 src/main/resources/application.properties
+resource-server/src/main/resources/application.properties
 
 # compile artifacts
 .kotlin/

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

@@ -9,6 +9,10 @@ develocity {
         val overriddenName = buildScanUsername.orNull
         server = "https://ge.jetbrains.com/"
         buildScan {
+
+            termsOfUseUrl = "https://gradle.com/help/legal-terms-of-use"
+            termsOfUseAgree = "yes"
+
             publishing.onlyIf { true }
             capture {
                 fileFingerprints = true

build.gradle.kts

@@ -1,5 +1,6 @@
 import org.gradle.kotlin.dsl.support.serviceOf
 import org.jetbrains.kotlin.gradle.targets.js.nodejs.NodeJsPlugin.Companion.kotlinNodeJsEnvSpec
+import org.jetbrains.kotlin.gradle.targets.js.nodejs.NodeJsRootExtension
 import org.jetbrains.kotlin.gradle.targets.js.nodejs.NodeJsRootPlugin
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 import org.springframework.boot.gradle.tasks.bundling.BootJar
@@ -20,10 +21,15 @@ plugins {
 
 apply<NodeJsRootPlugin>()
 
-allprojects {
-    afterEvaluate {
-        dependencies {
-            dependencies {
+setOf(
+    rootProject,
+    project(":common"),
+    project(":executors"),
+    project(":indexation"),
+).forEach { project ->
+    project.afterEvaluate {
+        project.dependencies {
+            project.dependencies {
                 implementation(libs.jackson.module.kotlin)
                 implementation(libs.kotlin.idea) {
                     isTransitive = false
@@ -33,9 +39,32 @@ allprojects {
     }
 }
 
-val resourceDependency: Configuration by configurations.creating {
+val kotlinComposeWasmStdlibFile: Configuration by configurations.creating {
+    isTransitive = false
     isCanBeResolved = true
     isCanBeConsumed = false
+    attributes {
+        attribute(
+            Category.CATEGORY_ATTRIBUTE,
+            objects.categoryComposeCache
+        )
+        attribute(
+            CacheAttribute.cacheAttribute,
+            CacheAttribute.WASM
+        )
+    }
+}
+
+val composeWasmStaticResources: Configuration by configurations.creating {
+    isTransitive = false
+    isCanBeResolved = true
+    isCanBeConsumed = false
+    attributes {
+        attribute(
+            Category.CATEGORY_ATTRIBUTE,
+            objects.categoryComposeWasmResources
+        )
+    }
 }
 
 dependencies {
@@ -64,44 +93,67 @@ dependencies {
     }
     testImplementation(libs.kotlinx.coroutines.test)
 
-    resourceDependency(libs.skiko.js.wasm.runtime)
+    kotlinComposeWasmStdlibFile(project(":cache-maker"))
+    composeWasmStaticResources(project(":resource-server"))
 }
 
-fun buildPropertyFile() {
-    rootDir.resolve("src/main/resources/${propertyFile}").apply {
-        println("Generate properties into $absolutePath")
-        parentFile.mkdirs()
-        writeText(generateProperties())
+fun Project.generateProperties(
+    prefix: String = "",
+): Map<String, String> = mapOf(
+    "kotlin.version" to kotlinVersion,
+    "policy.file" to prefix + policy,
+    "indexes.file" to prefix + indexes,
+    "indexesJs.file" to prefix + indexesJs,
+    "indexesWasm.file" to prefix + indexesWasm,
+    "indexesComposeWasm.file" to prefix + indexesComposeWasm,
+    "libraries.folder.jvm" to prefix + libJVM,
+    "libraries.folder.js" to prefix + libJS,
+    "libraries.folder.wasm" to prefix + libWasm,
+    "libraries.folder.compose-wasm" to prefix + libComposeWasm,
+    "libraries.folder.compose-wasm-compiler-plugins" to prefix + libComposeWasmCompilerPlugins,
+    "libraries.folder.compiler-plugins" to prefix + compilerPluginsForJVM,
+    "spring.mvc.pathmatch.matching-strategy" to "ant_path_matcher",
+    "spring.main.banner-mode" to "off",
+    "server.compression.enabled" to "true",
+    "server.compression.mime-types" to "application/json,text/javascript,application/wasm",
+    "springdoc.swagger-ui.path" to "/api-docs/swagger-ui.html",
+    "skiko.version" to libs.versions.skiko.get(),
+)
+
+val propertiesGenerator by tasks.registering(PropertiesGenerator::class) {
+    dependsOn(kotlinComposeWasmStdlibFile)
+    propertiesFile.fileValue(rootDir.resolve("src/main/resources/${propertyFile}"))
+    hashableFile.fileProvider(
+        provider {
+            kotlinComposeWasmStdlibFile.singleFile
+        }
+    )
+    generateProperties().forEach { (name, value) ->
+        propertiesMap.put(name, value)
     }
 }
 
-fun generateProperties(prefix: String = "") = """
-    # this file is autogenerated by build.gradle.kts
-    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}
-    libraries.folder.compose-wasm=${prefix + libComposeWasm}
-    libraries.folder.compose-wasm-compiler-plugins=${prefix + libComposeWasmCompilerPlugins}
-    libraries.folder.compiler-plugins=${prefix + compilerPluginsForJVM}
-    spring.mvc.pathmatch.matching-strategy=ant_path_matcher
-    server.compression.enabled=true
-    server.compression.mime-types=application/json,text/javascript,application/wasm
-    springdoc.swagger-ui.path: /api-docs/swagger-ui.html
-""".trimIndent()
+val lambdaPropertiesGenerator by tasks.registering(PropertiesGenerator::class) {
+    dependsOn(kotlinComposeWasmStdlibFile)
+    propertiesFile.set(layout.buildDirectory.file("tmp/propertiesGenerator/${propertyFile}"))
+    hashableFile.fileProvider(
+        provider {
+            kotlinComposeWasmStdlibFile.singleFile
+        }
+    )
+
+    generateProperties(lambdaPrefix).forEach { (name, value) ->
+        propertiesMap.put(name, value)
+    }
+}
 
 tasks.withType<KotlinCompile> {
     compilerOptions {
         freeCompilerArgs.set(listOf("-Xjsr305=strict"))
     }
     dependsOn(":executors:jar")
     dependsOn(":indexation:run")
-    buildPropertyFile()
+    dependsOn(propertiesGenerator)
 }
 println("Using Kotlin compiler ${libs.versions.kotlin.get()}")
 
@@ -110,18 +162,19 @@ tasks.withType<BootJar> {
     requiresUnpack("**/kotlinx-*.jar")
 }
 
+val prepareComposeWasmResources by tasks.registering(Sync::class) {
+    from(composeWasmStaticResources)
+    into(layout.buildDirectory.dir("compose-wasm-resources"))
+}
+
 val buildLambda by tasks.creating(Zip::class) {
     val propertyFile = propertyFile
-    val propertyFileContent = generateProperties("/var/task/")
 
     from(tasks.compileKotlin)
     from(tasks.processResources) {
-        eachFile {
-            if (name == propertyFile) {
-                file.writeText(propertyFileContent)
-            }
-        }
+        exclude(propertyFile)
     }
+    from(lambdaPropertiesGenerator)
     from(policy)
     from(indexes)
     from(indexesJs)
@@ -131,20 +184,18 @@ val buildLambda by tasks.creating(Zip::class) {
     from(libWasmFolder) { into(libWasm) }
     from(libComposeWasmFolder) { into(libComposeWasm) }
     from(libJVMFolder) { into(libJVM) }
-    from(compilerPluginsForJVMFolder) {into(compilerPluginsForJVM)}
+    from(compilerPluginsForJVMFolder) { into(compilerPluginsForJVM) }
     from(libComposeWasmCompilerPluginsFolder) { into(libComposeWasmCompilerPlugins) }
+    dependsOn(kotlinComposeWasmStdlibFile)
     into("lib") {
         from(configurations.compileClasspath) { exclude("tomcat-embed-*") }
     }
+
+    dependsOn(prepareComposeWasmResources)
 }
 
 tasks.named<Copy>("processResources") {
-    val archiveOperation = project.serviceOf<ArchiveOperations>()
-    from(resourceDependency.map {
-        archiveOperation.zipTree(it)
-    }) {
-        into("com/compiler/server")
-    }
+    dependsOn(propertiesGenerator)
 }
 
 tasks.withType<Test> {

buildSrc/src/main/kotlin/CacheAttribute.kt

@@ -0,0 +1,10 @@
+import org.gradle.api.attributes.Attribute
+
+enum class CacheAttribute {
+    FULL,
+    WASM;
+
+    companion object {
+        val cacheAttribute = Attribute.of("org.jetbrains.kotlin-compiler-server.cache", CacheAttribute::class.java)
+    }
+}

buildSrc/src/main/kotlin/CategoryAttribute.kt

@@ -0,0 +1,8 @@
+import org.gradle.api.attributes.Category
+import org.gradle.api.model.ObjectFactory
+
+val ObjectFactory.categoryComposeCache
+    get() = named(Category::class.java, "compose-cache")
+
+val ObjectFactory.categoryComposeWasmResources
+    get() = named(Category::class.java, "compose-wasm-resources")

buildSrc/src/main/kotlin/PropertiesUpdater.kt

@@ -0,0 +1,57 @@
+import org.gradle.api.DefaultTask
+import org.gradle.api.file.RegularFileProperty
+import org.gradle.api.provider.MapProperty
+import org.gradle.api.tasks.Input
+import org.gradle.api.tasks.InputFile
+import org.gradle.api.tasks.OutputFile
+import org.gradle.api.tasks.TaskAction
+import java.io.File
+import java.io.FileInputStream
+import java.security.MessageDigest
+
+abstract class PropertiesGenerator : DefaultTask() {
+
+    @get:InputFile
+    abstract val hashableFile: RegularFileProperty
+
+    @get:Input
+    abstract val propertiesMap: MapProperty<String, String>
+
+    @get:OutputFile
+    abstract val propertiesFile: RegularFileProperty
+
+    @TaskAction
+    fun updateProperties() {
+        val file = propertiesFile.get().asFile
+
+        propertiesMap.get().let {
+            if (it.isNotEmpty()) {
+                file.writeText("")
+                it.forEach { (key, value) ->
+                    file.appendText("$key=$value\n")
+                }
+            }
+        }
+
+        file.appendText(
+            "\ndependencies.compose.wasm=${hashFileContent(hashableFile.get().asFile.absolutePath)}"
+        )
+    }
+}
+
+fun hashFileContent(filePath: String, hashAlgorithm: String = "SHA-256"): String {
+    val file = File(filePath)
+    val digest = MessageDigest.getInstance(hashAlgorithm)
+
+    // Read the file content in chunks and update the digest
+    FileInputStream(file).use { fileInputStream ->
+        val buffer = ByteArray(1024)
+        var bytesRead: Int
+        while (fileInputStream.read(buffer).also { bytesRead = it } != -1) {
+            digest.update(buffer, 0, bytesRead)
+        }
+    }
+
+    // Convert the resulting byte array to a readable hex string
+    return digest.digest().joinToString("") { "%02x".format(it) }
+}

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

@@ -0,0 +1,46 @@
+import org.jetbrains.kotlin.gradle.dsl.KotlinProjectExtension
+
+extensions.configure<KotlinProjectExtension>("kotlin") {
+    logger.info("For the ${project.name} we used $kotlinVersion kotlin version in this build.")
+
+    sourceSets.configureEach {
+        languageSettings {
+            val kotlinLanguageVersion = project.providers.gradleProperty("kotlin_language_version")
+            if (kotlinLanguageVersion.isPresent) {
+                languageVersion = kotlinLanguageVersion.get()
+                logger.info("An overriding Kotlin language version of $languageVersion was found for project ${project.name}")
+            }
+            val kotlinApiVersion = project.providers.gradleProperty("kotlin_api_version")
+            if (kotlinApiVersion.isPresent) {
+                apiVersion = kotlinApiVersion.get()
+                logger.info("An overriding Kotlin api version of $apiVersion was found for project ${project.name}")
+            }
+        }
+    }
+
+    jvmToolchain {
+        languageVersion.set(JavaLanguageVersion.of(17))
+        vendor.set(JvmVendorSpec.AMAZON)
+    }
+}
+
+tasks.withType<org.jetbrains.kotlin.gradle.tasks.KotlinCompile>().configureEach {
+    compilerOptions {
+
+        freeCompilerArgs.addAll(
+            "-Xreport-all-warnings",
+            "-Xrender-internal-diagnostic-names",
+            "-Xuse-fir-experimental-checkers"
+        )
+
+        allWarningsAsErrors.set(false)
+        extraWarnings.set(true)
+
+        // Adding additional cli options for testing purpose
+        project.providers.gradleProperty("kotlin_additional_cli_options").orNull?.let { options ->
+            options.split(" ").filter { it.isNotBlank() }.forEach {
+                freeCompilerArgs.add(it)
+            }
+        }
+    }
+}