[Gradle] Config Cache for platform commonizer task

^KT-49933

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/compilerRunner/GradleCliCommonizer.kt

@@ -20,16 +20,6 @@ import org.jetbrains.kotlin.gradle.utils.named
 
 private const val KOTLIN_KLIB_COMMONIZER_EMBEDDABLE = "kotlin-klib-commonizer-embeddable"
 
-/**
- * Creates an instance of [CliCommonizer] that is backed by [KotlinNativeCommonizerToolRunner] to adhere to user defined settings
- * when executing the commonizer (like jvm arguments, running in separate process, etc)
- */
-internal fun GradleCliCommonizer(project: Project): CliCommonizer {
-    return GradleCliCommonizer(
-        KotlinNativeCommonizerToolRunner(project)
-    )
-}
-
 internal fun GradleCliCommonizer(commonizerToolRunner: KotlinNativeCommonizerToolRunner): CliCommonizer {
     return CliCommonizer(CliCommonizer.Executor { arguments ->
         commonizerToolRunner.run(arguments)

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/compilerRunner/KotlinNativeCommonizerToolRunner.kt

@@ -6,32 +6,62 @@
 package org.jetbrains.kotlin.compilerRunner
 
 import org.gradle.api.Project
+import org.gradle.api.tasks.Classpath
+import org.gradle.api.tasks.Input
 import org.jetbrains.kotlin.gradle.plugin.KLIB_COMMONIZER_CLASSPATH_CONFIGURATION_NAME
 import org.jetbrains.kotlin.gradle.plugin.PropertiesProvider
 import org.jetbrains.kotlin.gradle.plugin.getKotlinPluginVersion
 import java.io.File
 
-internal class KotlinNativeCommonizerToolRunner(project: Project) : KotlinToolRunner(project) {
+internal class KotlinNativeCommonizerToolRunner(
+    context: GradleExecutionContext,
+    private val settings: Settings,
+) : KotlinToolRunner(context) {
+
+    class Settings(
+        @get:Input
+        val kotlinPluginVersion: String,
+        classpathProvider: () -> Set<File>,
+        @get:Input
+        val customJvmArgs: List<String>
+    ) {
+        @get:Classpath
+        val classpath by lazy(classpathProvider)
+
+        constructor(project: Project) : this(
+            kotlinPluginVersion = project.getKotlinPluginVersion(),
+            classpathProvider = { buildClasspath(project) },
+            customJvmArgs = getCustomJvmArgs(project)
+        )
+    }
+
     override val displayName get() = "Kotlin/Native KLIB commonizer"
 
     override val mainClass: String get() = "org.jetbrains.kotlin.commonizer.cli.CommonizerCLI"
 
-    override val classpath by lazy {
-        try {
-            project.configurations.getByName(KLIB_COMMONIZER_CLASSPATH_CONFIGURATION_NAME).resolve() as Set<File>
-        } catch (e: Exception) {
-            project.logger.error(
-                "Could not resolve KLIB commonizer classpath. Check if Kotlin Gradle plugin repository is configured in $project."
-            )
-            throw e
-        }
-    }
+    override val classpath: Set<File> get() = settings.classpath
 
-    override val isolatedClassLoaderCacheKey get() = project.getKotlinPluginVersion()
+    override val isolatedClassLoaderCacheKey get() = settings.kotlinPluginVersion
 
     override val defaultMaxHeapSize: String get() = "4G"
 
     override val mustRunViaExec get() = true // because it's not enough the standard Gradle wrapper's heap size
 
-    override fun getCustomJvmArgs() = PropertiesProvider(project).commonizerJvmArgs?.split("\\s+".toRegex()).orEmpty()
+    override fun getCustomJvmArgs() = settings.customJvmArgs
 }
+
+private fun buildClasspath(project: Project): Set<File> {
+    try {
+        return project.configurations.getByName(KLIB_COMMONIZER_CLASSPATH_CONFIGURATION_NAME).resolve() as Set<File>
+    } catch (e: Exception) {
+        project.logger.error(
+            "Could not resolve KLIB commonizer classpath. Check if Kotlin Gradle plugin repository is configured in $project."
+        )
+        throw e
+    }
+}
+
+private fun getCustomJvmArgs(project: Project): List<String> = PropertiesProvider(project)
+    .commonizerJvmArgs
+    ?.split("\\s+".toRegex())
+    .orEmpty()

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/compilerRunner/KotlinToolRunner.kt

@@ -52,7 +52,7 @@ abstract class KotlinToolRunner(
                 logger: Logger
             ) = GradleExecutionContext(
                 filesProvider = objectFactory.fileCollection()::from,
-                javaexec = execOperations::javaexec,
+                javaexec = { spec -> execOperations.javaexec(spec) }, // execOperations::javaexec won't work due to different Classloaders
                 logger = logger
             )
         }

libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/targets/native/internal/NativeDistributionCommonizerTask.kt

@@ -7,9 +7,11 @@ package org.jetbrains.kotlin.gradle.targets.native.internal
 
 import org.gradle.api.DefaultTask
 import org.gradle.api.Project
-import org.gradle.api.tasks.Internal
-import org.gradle.api.tasks.TaskAction
+import org.gradle.api.model.ObjectFactory
+import org.gradle.api.tasks.*
+import org.gradle.process.ExecOperations
 import org.jetbrains.kotlin.commonizer.SharedCommonizerTarget
+import org.jetbrains.kotlin.compilerRunner.*
 import org.jetbrains.kotlin.compilerRunner.GradleCliCommonizer
 import org.jetbrains.kotlin.compilerRunner.KotlinNativeCommonizerToolRunner
 import org.jetbrains.kotlin.compilerRunner.konanHome
@@ -21,8 +23,13 @@ import org.jetbrains.kotlin.konan.library.KONAN_DISTRIBUTION_COMMONIZED_LIBS_DIR
 import org.jetbrains.kotlin.konan.library.KONAN_DISTRIBUTION_KLIB_DIR
 import java.io.File
 import java.net.URLEncoder
+import javax.inject.Inject
 
-internal open class NativeDistributionCommonizerTask : DefaultTask() {
+internal open class NativeDistributionCommonizerTask
+@Inject constructor (
+    private val objectFactory: ObjectFactory,
+    private val execOperations: ExecOperations,
+) : DefaultTask() {
 
     private val konanHome = project.file(project.konanHome)
 
@@ -30,16 +37,18 @@ internal open class NativeDistributionCommonizerTask : DefaultTask() {
         project.collectAllSharedCommonizerTargetsFromBuild()
     }
 
-    private val commonizer by lazy {
-        NativeDistributionCommonizationCache(
-            logger = project.logger,
-            isCachingEnabled = project.kotlinPropertiesProvider.enableNativeDistributionCommonizationCache,
-            commonizer = GradleCliCommonizer(KotlinNativeCommonizerToolRunner(project))
-        )
-    }
+    private val runnerSettings = KotlinNativeCommonizerToolRunner.Settings(project)
+
+    private val isCachingEnabled = project.kotlinPropertiesProvider.enableNativeDistributionCommonizationCache
+
+    private val logLevel = project.commonizerLogLevel
+
+    private val additionalSettings = project.additionalCommonizerSettings
+
+    private val kotlinVersion by lazy { project.getKotlinPluginVersion() }
 
     @get:Internal
-    internal val rootOutputDirectory: File by lazy {
+    internal val rootOutputDirectory: File = project.file {
         project.file(konanHome)
             .resolve(KONAN_DISTRIBUTION_KLIB_DIR)
             .resolve(KONAN_DISTRIBUTION_COMMONIZED_LIBS_DIR)
@@ -48,20 +57,32 @@ internal open class NativeDistributionCommonizerTask : DefaultTask() {
 
     @TaskAction
     protected fun run() {
+        val commonizerRunner = KotlinNativeCommonizerToolRunner(
+            context = KotlinToolRunner.GradleExecutionContext.fromTaskContext(objectFactory, execOperations, logger),
+            settings = runnerSettings
+        )
+
+        val commonizer = NativeDistributionCommonizationCache(
+            isCachingEnabled = isCachingEnabled,
+            logger = logger,
+            commonizer = GradleCliCommonizer(commonizerRunner)
+        )
+
         commonizer.commonizeNativeDistribution(
             konanHome = konanHome,
             outputDirectory = rootOutputDirectory,
             outputTargets = commonizerTargets,
-            logLevel = project.commonizerLogLevel,
-            additionalSettings = project.additionalCommonizerSettings,
+            logLevel = logLevel,
+            additionalSettings = additionalSettings,
         )
     }
 
     init {
         project.registerCommonizerClasspathConfigurationIfNecessary()
-        outputs.upToDateWhen {
-            commonizer.isUpToDate(konanHome, rootOutputDirectory, commonizerTargets)
-        }
+        // TODO(alakotka): Support upToDate checks
+//        outputs.upToDateWhen {
+//            commonizer.isUpToDate(konanHome, rootOutputDirectory, commonizerTargets)
+//        }
     }
 }