Revert accidental push

skiko/build.gradle.kts

@@ -3,7 +3,6 @@ import org.gradle.crypto.checksum.Checksum
 import org.gradle.api.tasks.testing.AbstractTestTask
 import org.jetbrains.compose.internal.publishing.MavenCentralProperties
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinNativeTarget
-import org.jetbrains.kotlin.gradle.plugin.KotlinTarget
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 import org.jetbrains.kotlin.gradle.tasks.KotlinNativeCompile
 import org.gradle.api.tasks.testing.logging.TestExceptionFormat
@@ -24,6 +23,7 @@ fun targetSuffix(os: OS, arch: Arch): String {
 
 val skiko = SkikoProperties(rootProject)
 val buildType = skiko.buildType
+val generatedKotlin = "$buildDir/kotlin/commonMain"
 
 allprojects {
     group = "org.jetbrains.skiko"
@@ -132,7 +132,7 @@ if (supportWasm) {
 fun compileNativeBridgesTask(os: OS, arch: Arch): TaskProvider<CompileSkikoCppTask> {
     val skiaNativeDir = registerOrGetSkiaDirProvider(os, arch)
 
-    return project.registerSkikoTask<CompileSkikoCppTask>("compileNativeBridges", os, arch) {
+    return tasks.register<CompileSkikoCppTask>("${os.id}_${arch.id}_CrossCompile") {
         dependsOn(skiaNativeDir)
         val unpackedSkia = skiaNativeDir.get()
 
@@ -218,17 +218,13 @@ kotlin {
         compilations.all {
             kotlinOptions.jvmTarget = "11"
         }
-        generateVersion(targetOs, targetArch)
     }
 
     if (supportAndroid) {
-        // todo: use android target
         jvm("android") {
             compilations.all {
                 kotlinOptions.jvmTarget = "11"
             }
-            // todo: what is the actual target arch? what does "jvm(android)" target even mean?
-            generateVersion(OS.Android, targetArch)
         }
     }
 
@@ -243,7 +239,6 @@ kotlin {
                 }
             }
             binaries.executable()
-            generateVersion(OS.Wasm, Arch.Wasm)
         }
     }
 
@@ -416,8 +411,6 @@ kotlin {
 fun configureNativeTarget(os: OS, arch: Arch, target: KotlinNativeTarget) {
     if (!os.isCompatibleWithHost) return
 
-    target.generateVersion(os, arch)
-
     val targetString = "${os.id}-${arch.id}"
 
     val unzipper = registerOrGetSkiaDirProvider(os, arch)
@@ -467,7 +460,7 @@ fun configureNativeTarget(os: OS, arch: Arch, target: KotlinNativeTarget) {
 
     val crossCompileTask = compileNativeBridgesTask(os, arch)
 
-    val linkTask = project.registerSkikoTask<Exec>("linkNativeBridges", targetOs, targetArch) {
+    val linkTask = project.tasks.register<Exec>("linkNativeBridges$targetString") {
         dependsOn(crossCompileTask)
         val objectFilesDir = crossCompileTask.map { it.outDir.get() }
         val objectFiles = project.fileTree(objectFilesDir) {
@@ -627,11 +620,8 @@ fun androidJar(version: String = "30"): String {
     return androidHome.resolve("platforms/android-$version/android.jar").absolutePath
 }
 
-fun createCompileJvmBindingsTask(
-    targetOs: OS,
-    targetArch: Arch,
-    skiaJvmBindingsDir: Provider<File>
-) = project.registerSkikoTask<CompileSkikoCppTask>("compileJvmBindings", targetOs, targetArch) {
+fun createCompileJvmBindingsTask(targetOs: OS, targetArch: Arch, skiaJvmBindingsDir: Provider<File>) =
+    tasks.register<CompileSkikoCppTask>("compileJvmBindings-${targetOs.id}-${targetArch.id}") {
     // Prefer 'java.home' system property to simplify overriding from Intellij.
     // When used from command-line, it is effectively equal to JAVA_HOME.
     if (JavaVersion.current() < JavaVersion.VERSION_11) {
@@ -731,12 +721,10 @@ fun createCompileJvmBindingsTask(
     )
 }
 
-fun createLinkJvmBindings(
-    targetOs: OS,
-    targetArch: Arch,
-    skiaJvmBindingsDir: Provider<File>,
-    compileTask: TaskProvider<CompileSkikoCppTask>
-) = project.registerSkikoTask<LinkSkikoTask>("linkJvmBindings", targetOs, targetArch) {
+fun createLinkJvmBindings(targetOs: OS, targetArch: Arch,
+                          skiaJvmBindingsDir: Provider<File>,
+                          compileTask: TaskProvider<CompileSkikoCppTask>) =
+    tasks.register<LinkSkikoTask>("linkJvmBindings-${targetOs.id}-${targetArch.id}") {
         val target = targetId(targetOs, targetArch)
         val skiaBinSubdir = "out/${buildType.id}-$target"
         val skiaBinDir = skiaJvmBindingsDir.get().absolutePath + "/" + skiaBinSubdir
@@ -865,38 +853,23 @@ if (hostOs == OS.MacOS) {
     }
 }
 
-fun KotlinTarget.generateVersion(
-    targetOs: OS,
-    targetArch: Arch
-) {
-    val targetName = this.name
-    val generatedDir = project.layout.buildDirectory.dir("generated/$targetName")
-    val generateVersionTask = project.registerSkikoTask<DefaultTask>("generateVersion", targetOs, targetArch) {
-        inputs.property("buildType", buildType.id)
-        outputs.dir(generatedDir)
-        doFirst {
-            val outDir = generatedDir.get().asFile
-            outDir.deleteRecursively()
-            outDir.mkdirs()
-            val out = "$outDir/Version.kt"
-
-            val target = "${targetOs.id}-${targetArch.id}"
-            val skiaTag = project.property("dependencies.skia.$target") as String
-            File(out).writeText("""
-                package org.jetbrains.skiko
-                object Version {
-                  val skiko = "${skiko.deployVersion}"
-                  val skia = "${skiaTag}"
-                }
-                """.trimIndent()
-            )
+val generateVersion = generateVersionTask(targetOs, targetArch)
+
+fun generateVersionTask(targetOs: OS, targetArch: Arch) = project.tasks.register("generateVersion") {
+    val outDir = generatedKotlin
+    file(outDir).mkdirs()
+    val out = "$outDir/Version.kt"
+    outputs.dir(outDir)
+    doFirst {
+        val target = "${targetOs.id}-${targetArch.id}"
+        val skiaTag = project.property("dependencies.skia.$target") as String
+        File(out).writeText("""
+        package org.jetbrains.skiko
+        object Version {
+          val skiko = "${skiko.deployVersion}"
+          val skia = "${skiaTag}"
         }
-    }
-
-    val compilation = compilations["main"] ?: error("Could not find 'main' compilation for target '$this'")
-    compilation.compileKotlinTaskProvider.configure {
-        dependsOn(generateVersionTask)
-        (this as AbstractCompile).source(generatedDir.get().asFile)
+        """.trimIndent())
     }
 }
 
@@ -905,11 +878,8 @@ val skikoJvmJar by project.tasks.registering(Jar::class) {
     from(kotlin.jvm("awt").compilations["main"].output.allOutputs)
 }
 
-fun maybeSignTask(
-    targetOs: OS,
-    targetArch: Arch,
-    linkJvmBindings: Provider<LinkSkikoTask>
-) = project.registerSkikoTask<SealAndSignSharedLibraryTask>("maybeSign", targetOs, targetArch) {
+fun maybeSignTask(targetOs: OS, targetArch: Arch, linkJvmBindings: Provider<LinkSkikoTask>) =
+    project.tasks.register<SealAndSignSharedLibraryTask>("maybeSign-${targetOs.id}-${targetArch.id}") {
     dependsOn(linkJvmBindings)
 
     val linkOutputFile = linkJvmBindings.map { task ->
@@ -937,12 +907,10 @@ fun maybeSignTask(
     signToken.set(skiko.signToken)
 }
 
-fun createChecksumsTask(
-    targetOs: OS,
-    targetArch: Arch,
-    maybeSign: Provider<SealAndSignSharedLibraryTask>,
-    bindingsDir: Provider<File>
-) = project.registerSkikoTask<Checksum>("createChecksums", targetOs, targetArch) {
+fun createChecksumsTask(targetOs: OS, targetArch: Arch,
+                        maybeSign: Provider<SealAndSignSharedLibraryTask>,
+                        bindingsDir: Provider<File>) =
+    project.tasks.register<Checksum>("createChecksums-${targetOs.id}-${targetArch.id}") {
         val skiaBinSubdir = "out/${buildType.id}-${targetOs.id}-${targetArch.id}"
         dependsOn(maybeSign)
         files = project.files(maybeSign.flatMap { it.outputFiles }) +
@@ -951,13 +919,11 @@ fun createChecksumsTask(
         outputDir = file("$buildDir/checksums")
     }
 
-fun skikoJvmRuntimeJarTask(
-    targetOs: OS,
-    targetArch: Arch,
-    maybeSign: Provider<SealAndSignSharedLibraryTask>,
-    createChecksums: Provider<Checksum>,
-    bindingsDir: Provider<File>
-) = project.registerSkikoTask<Jar>("skikoJvmRuntimeJar", targetOs, targetArch) {
+fun skikoJvmRuntimeJarTask(targetOs: OS, targetArch: Arch,
+                           maybeSign: Provider<SealAndSignSharedLibraryTask>,
+                           createChecksums: Provider<Checksum>,
+                           bindingsDir: Provider<File>) =
+  project.tasks.register<Jar>("skikoJvmRuntimeJar-${targetOs.id}-${targetArch.id}") {
       dependsOn(maybeSign)
       dependsOn(createChecksums)
       dependsOn(skikoJvmJar)
@@ -972,11 +938,9 @@ fun skikoJvmRuntimeJarTask(
       from(createChecksums.map { it.outputs.files })
 }
 
-fun skikoRuntimeDirForTestsTask(
-    targetOs: OS,
-    targetArch: Arch,
-    skikoJvmRuntimeJar: Provider<Jar>
-) = project.registerSkikoTask<Copy>("skikoRuntimeDirForTests", targetOs, targetArch) {
+fun skikoRuntimeDirForTestsTask(targetOs: OS, targetArch: Arch,
+                                skikoJvmRuntimeJar: Provider<Jar>) =
+  project.tasks.register<Copy>("skikoRuntimeDirForTests-${targetOs.id}-${targetArch.id}") {
     dependsOn(skikoJvmRuntimeJar)
     from(zipTree(skikoJvmRuntimeJar.flatMap { it.archiveFile })) {
         include("*.so")
@@ -1104,13 +1068,12 @@ publishing {
         allJvmRuntimeJars.forEach { entry ->
             val os = entry.key.first
             val arch = entry.key.second
-            create<MavenPublication>("skikoJvmRuntime${toTitleCase(os.id)}${toTitleCase(arch.id)}") {
+            create<MavenPublication>("skikoJvmRuntime${targetId(os, arch)}") {
                 pomNameForPublication[name] = "Skiko JVM Runtime for ${os.name} ${arch.name}"
                 artifactId = SkikoArtifacts.jvmRuntimeArtifactIdFor(os, arch)
                 afterEvaluate {
                     artifact(entry.value.map { it.archiveFile.get() })
                     var jvmSourcesArtifact: Any? = null
-                    // todo: use correct sources jar for each jvm source set
                     kotlin.jvm("awt").mavenPublication {
                         jvmSourcesArtifact = artifacts.find { it.classifier == "sources" }
                     }
@@ -1153,10 +1116,17 @@ if (skiko.isCIBuild || mavenCentral.signArtifacts) {
 
 afterEvaluate {
     tasks.withType<KotlinCompile>().configureEach { // this one is actually KotlinJvmCompile
+        dependsOn(generateVersion)
+        source(generatedKotlin)
+
         if (name == "compileTestKotlinJvm") {
             kotlinOptions.freeCompilerArgs += "-Xopt-in=kotlin.RequiresOptIn"
         }
     }
+    tasks.withType<KotlinNativeCompile>().configureEach {
+        dependsOn(generateVersion)
+        source(generatedKotlin)
+    }
 }
 
 // Kotlin/JS has a bug preventing compilation on non-x86 Linux machines,

skiko/buildSrc/src/main/kotlin/utils.kt

-import org.gradle.api.Project
 import org.gradle.api.Task
 import org.gradle.api.file.Directory
 import org.gradle.api.provider.Provider
 import org.gradle.api.tasks.TaskContainer
-import org.gradle.api.tasks.TaskProvider
 import org.gradle.kotlin.dsl.register
 import java.util.*
 
@@ -18,21 +16,6 @@ inline fun <reified T : Task> TaskContainer.registerOrGetTask(
     return taskProvider.map { it as T }
 }
 
-inline fun <reified T : Task> Project.registerSkikoTask(
-    taskName: String,
-    crossinline fn: T.() -> Unit
-): TaskProvider<T> = tasks.register(taskName, T::class) { fn() }
-
-inline fun <reified T : Task> Project.registerSkikoTask(
-    actionName: String,
-    targetOs: OS,
-    targetArch: Arch,
-    crossinline fn: T.() -> Unit
-): TaskProvider<T> {
-    val taskName = joinToTitleCamelCase(actionName, targetOs.id, targetArch.id)
-    return registerSkikoTask(taskName, fn)
-}
-
 fun joinToTitleCamelCase(vararg parts: String): String =
     parts.joinToString(separator = "") { toTitleCase(it) }