[Gradle] Add Gradle & task property to set compiler execution strategy

#KT-49299 Fixed

libraries/tools/kotlin-gradle-plugin-api/src/main/kotlin/org/jetbrains/kotlin/gradle/tasks/CompileUsingKotlinDaemon.kt

@@ -7,8 +7,48 @@ package org.jetbrains.kotlin.gradle.tasks
 
 import org.gradle.api.Task
 import org.gradle.api.provider.ListProperty
+import org.gradle.api.provider.Property
 import org.gradle.api.tasks.Internal
 
+enum class KotlinCompilerExecutionStrategy(
+    /**
+     * Value that should be passed for `kotlin.compiler.execution.strategy` Gradle or system property to choose the strategy
+     */
+    val propertyValue: String
+) {
+    /**
+     * Execute Kotlin compiler in its own daemon. Default strategy.
+     *
+     * Daemon may be shared across multiple compile tasks if it's considered compatible
+     */
+    DAEMON("daemon"),
+
+    /**
+     * Execute Kotlin compiler inside the Gradle process
+     *
+     * Note: currently this strategy doesn't support incremental compilation
+     */
+    IN_PROCESS("in-process"),
+
+    /**
+     * Execute Kotlin compiler in a new forked process for each compilation
+     *
+     * Note: currently this strategy doesn't support incremental compilation
+     */
+    OUT_OF_PROCESS("out-of-process"),
+    ;
+
+    companion object {
+        fun fromProperty(value: String?) =
+            if (value == null) {
+                DAEMON
+            } else {
+                values().find { it.propertyValue.equals(value, ignoreCase = true) }
+                    ?: error("Unknown value '$value' is passed for Kotlin compiler execution strategy")
+            }
+    }
+}
+
 /**
  * Task is using Kotlin daemon to run compilation.
  */
@@ -18,4 +58,10 @@ interface CompileUsingKotlinDaemon : Task {
      */
     @get:Internal
     val kotlinDaemonJvmArguments: ListProperty<String>
+
+    /**
+     * Defines compiler execution strategy, see docs for [KotlinCompilerExecutionStrategy] for more details
+     */
+    @get:Internal
+    val compilerExecutionStrategy: Property<KotlinCompilerExecutionStrategy>
 }

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/ExecutionStrategyIT.kt

@@ -1,5 +1,6 @@
 package org.jetbrains.kotlin.gradle
 
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompilerExecutionStrategy
 import org.jetbrains.kotlin.gradle.util.checkedReplace
 import org.jetbrains.kotlin.gradle.util.getFileByName
 import org.jetbrains.kotlin.gradle.util.modify
@@ -45,46 +46,67 @@ class ExecutionStrategyJvmIT : ExecutionStrategyIT() {
 abstract class ExecutionStrategyIT : BaseGradleIT() {
     @Test
     fun testDaemon() {
-        doTestExecutionStrategy("daemon", addHeapDumpOptions = false)
+        doTestExecutionStrategy(KotlinCompilerExecutionStrategy.DAEMON, addHeapDumpOptions = false)
+    }
+
+    @Test
+    fun testDaemonViaSystemProperty() {
+        doTestExecutionStrategy(KotlinCompilerExecutionStrategy.DAEMON, addHeapDumpOptions = false, viaSystemProperty = true)
     }
 
     @Test
     fun testInProcess() {
-        doTestExecutionStrategy("in-process")
+        doTestExecutionStrategy(KotlinCompilerExecutionStrategy.IN_PROCESS)
+    }
+
+    @Test
+    fun testInProcessViaSystemProperty() {
+        doTestExecutionStrategy(KotlinCompilerExecutionStrategy.IN_PROCESS, viaSystemProperty = true)
     }
 
     @Test
     fun testOutOfProcess() {
-        doTestExecutionStrategy("out-of-process")
+        doTestExecutionStrategy(KotlinCompilerExecutionStrategy.OUT_OF_PROCESS)
     }
 
-    private fun doTestExecutionStrategy(executionStrategy: String, addHeapDumpOptions: Boolean = true) {
+    @Test
-        val project = Project("kotlinBuiltins", addHeapDumpOptions = addHeapDumpOptions)
+    fun testOutOfProcessViaSystemProperty() {
-        setupProject(project)
+        doTestExecutionStrategy(KotlinCompilerExecutionStrategy.OUT_OF_PROCESS, viaSystemProperty = true)
+    }
 
-        val strategyCLIArg = "-Dkotlin.compiler.execution.strategy=$executionStrategy"
+    private fun doTestExecutionStrategy(
-        val finishMessage = "Finished executing kotlin compiler using $executionStrategy strategy"
+        executionStrategy: KotlinCompilerExecutionStrategy,
+        addHeapDumpOptions: Boolean = true,
+        viaSystemProperty: Boolean = false
+    ) {
+        with(Project("kotlinBuiltins", addHeapDumpOptions = addHeapDumpOptions)) {
+            setupProject(this)
 
-        project.build("build", strategyCLIArg) {
+            val cliArgPrefix = if (viaSystemProperty) "-D" else "-P"
-            assertSuccessful()
+            val strategyCLIArg = "${cliArgPrefix}kotlin.compiler.execution.strategy=${executionStrategy.propertyValue}"
-            assertContains(finishMessage)
+            val finishMessage = "Finished executing kotlin compiler using $executionStrategy strategy"
-            checkOutput()
-            assertNoWarnings()
 
-            if (executionStrategy == "daemon") {
+            build("build", strategyCLIArg) {
-                checkCompileDaemon()
+                assertSuccessful()
+                assertContains(finishMessage)
+                checkOutput()
+                assertNoWarnings()
+
+                if (executionStrategy == KotlinCompilerExecutionStrategy.DAEMON) {
+                    checkCompileDaemon()
+                }
             }
-        }
 
-        val classesKt = project.projectDir.getFileByName("classes.kt")
+            val classesKt = projectDir.getFileByName("classes.kt")
-        classesKt.modify {
+            classesKt.modify {
-            it.checkedReplace("class B", "//class B")
+                it.checkedReplace("class B", "//class B")
-        }
+            }
-        project.build("build", strategyCLIArg) {
+            build("build", strategyCLIArg) {
-            assertSuccessful()
+                assertSuccessful()
-            assertContains(finishMessage)
+                assertContains(finishMessage)
-            checkOutputAfterChange()
+                checkOutputAfterChange()
-            assertNoWarnings()
+                assertNoWarnings()
+            }
         }
     }
 

libraries/tools/kotlin-gradle-plugin-integration-tests/src/test/kotlin/org/jetbrains/kotlin/gradle/SimpleKotlinGradleIT.kt

@@ -3,6 +3,7 @@ package org.jetbrains.kotlin.gradle
 import org.gradle.api.logging.LogLevel
 import org.gradle.api.logging.configuration.WarningMode
 import org.gradle.util.GradleVersion
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompilerExecutionStrategy
 import org.jetbrains.kotlin.gradle.testbase.*
 import org.junit.jupiter.api.DisplayName
 
@@ -19,7 +20,7 @@ class SimpleKotlinGradleIT : KGPBaseTest() {
             buildOptions = defaultBuildOptions.copy(logLevel = LogLevel.DEBUG),
         ) {
             build("compileDeployKotlin", "build") {
-                assertOutputContains("Finished executing kotlin compiler using daemon strategy")
+                assertOutputContains("Finished executing kotlin compiler using ${KotlinCompilerExecutionStrategy.DAEMON} strategy")
                 assertFileInProjectExists("build/reports/tests/test/classes/demo.TestSource.html")
                 assertTasksExecuted(":compileKotlin", ":compileTestKotlin", ":compileDeployKotlin")
             }

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/compilerRunner/GradleCompilerRunnerWithWorkers.kt

@@ -17,6 +17,7 @@ import org.jetbrains.kotlin.build.report.metrics.BuildMetricsReporter
 import org.jetbrains.kotlin.build.report.metrics.BuildTime
 import org.jetbrains.kotlin.build.report.metrics.measure
 import org.jetbrains.kotlin.gradle.tasks.GradleCompileTaskProvider
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompilerExecutionStrategy
 import org.jetbrains.kotlin.gradle.tasks.TaskOutputsBackup
 import java.io.File
 import javax.inject.Inject
@@ -29,8 +30,9 @@ internal class GradleCompilerRunnerWithWorkers(
     jdkToolsJar: File?,
     kotlinDaemonJvmArgs: List<String>?,
     buildMetrics: BuildMetricsReporter,
+    compilerExecutionStrategy: KotlinCompilerExecutionStrategy,
     private val workerExecutor: WorkerExecutor
-) : GradleCompilerRunner(taskProvider, jdkToolsJar, kotlinDaemonJvmArgs, buildMetrics) {
+) : GradleCompilerRunner(taskProvider, jdkToolsJar, kotlinDaemonJvmArgs, buildMetrics, compilerExecutionStrategy) {
     override fun runCompilerAsync(
         workArgs: GradleKotlinCompilerWorkArguments,
         taskOutputsBackup: TaskOutputsBackup?

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/compilerRunner/GradleKotlinCompilerRunner.kt

@@ -16,6 +16,7 @@ import org.gradle.workers.WorkQueue
 import org.jetbrains.kotlin.build.report.metrics.BuildMetricsReporter
 import org.jetbrains.kotlin.build.report.metrics.BuildTime
 import org.jetbrains.kotlin.build.report.metrics.measure
+import org.jetbrains.kotlin.cli.common.CompilerSystemProperties
 import org.jetbrains.kotlin.cli.common.arguments.*
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector
 import org.jetbrains.kotlin.daemon.client.CompileServiceSession
@@ -43,10 +44,6 @@ import org.jetbrains.kotlin.statistics.metrics.StringMetrics
 import java.io.File
 import java.lang.ref.WeakReference
 
-internal const val KOTLIN_COMPILER_EXECUTION_STRATEGY_PROPERTY = "kotlin.compiler.execution.strategy"
-internal const val DAEMON_EXECUTION_STRATEGY = "daemon"
-internal const val IN_PROCESS_EXECUTION_STRATEGY = "in-process"
-internal const val OUT_OF_PROCESS_EXECUTION_STRATEGY = "out-of-process"
 const val CREATED_CLIENT_FILE_PREFIX = "Created client-is-alive flag file: "
 const val EXISTING_CLIENT_FILE_PREFIX = "Existing client-is-alive flag file: "
 const val CREATED_SESSION_FILE_PREFIX = "Created session-is-alive flag file: "
@@ -54,9 +51,6 @@ const val EXISTING_SESSION_FILE_PREFIX = "Existing session-is-alive flag file: "
 const val DELETED_SESSION_FILE_PREFIX = "Deleted session-is-alive flag file: "
 const val COULD_NOT_CONNECT_TO_DAEMON_MESSAGE = "Could not connect to Kotlin compile daemon"
 
-internal fun kotlinCompilerExecutionStrategy(): String =
-    System.getProperty(KOTLIN_COMPILER_EXECUTION_STRATEGY_PROPERTY) ?: DAEMON_EXECUTION_STRATEGY
-
 /*
 Using real taskProvider cause "field 'taskProvider' from type 'org.jetbrains.kotlin.compilerRunner.GradleCompilerRunner':
 value 'fixed(class org.jetbrains.kotlin.gradle.tasks.KotlinCompile_Decorated, task ':compileKotlin')'
@@ -66,7 +60,8 @@ internal open class GradleCompilerRunner(
     protected val taskProvider: GradleCompileTaskProvider,
     protected val jdkToolsJar: File?,
     protected val kotlinDaemonJvmArgs: List<String>?,
-    protected val buildMetrics: BuildMetricsReporter
+    protected val buildMetrics: BuildMetricsReporter,
+    protected val compilerExecutionStrategy: KotlinCompilerExecutionStrategy,
 ) {
 
     internal val pathProvider = taskProvider.path.get()
@@ -196,7 +191,8 @@ internal open class GradleCompilerRunner(
             reportingSettings = environment.reportingSettings,
             kotlinScriptExtensions = environment.kotlinScriptExtensions,
             allWarningsAsErrors = compilerArgs.allWarningsAsErrors,
-            daemonJvmArgs = kotlinDaemonJvmArgs
+            daemonJvmArgs = kotlinDaemonJvmArgs,
+            compilerExecutionStrategy = compilerExecutionStrategy,
         )
         TaskLoggers.put(pathProvider, loggerProvider)
         return runCompilerAsync(

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/compilerRunner/GradleKotlinCompilerWork.kt

@@ -21,6 +21,7 @@ import org.jetbrains.kotlin.gradle.report.*
 import org.jetbrains.kotlin.gradle.report.TaskExecutionInfo
 import org.jetbrains.kotlin.gradle.report.TaskExecutionProperties.ABI_SNAPSHOT
 import org.jetbrains.kotlin.gradle.report.TaskExecutionResult
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompilerExecutionStrategy
 import org.jetbrains.kotlin.gradle.tasks.clearLocalState
 import org.jetbrains.kotlin.gradle.tasks.throwGradleExceptionIfError
 import org.jetbrains.kotlin.gradle.utils.stackTraceAsString
@@ -68,7 +69,8 @@ internal class GradleKotlinCompilerWorkArguments(
     val reportingSettings: ReportingSettings,
     val kotlinScriptExtensions: Array<String>,
     val allWarningsAsErrors: Boolean,
-    val daemonJvmArgs: List<String>?
+    val daemonJvmArgs: List<String>?,
+    val compilerExecutionStrategy: KotlinCompilerExecutionStrategy,
 ) : Serializable {
     companion object {
         const val serialVersionUID: Long = 0
@@ -104,6 +106,7 @@ internal class GradleKotlinCompilerWork @Inject constructor(
     private val metrics = if (reportingSettings.reportMetrics) BuildMetricsReporterImpl() else DoNothingBuildMetricsReporter
     private var icLogLines: List<String> = emptyList()
     private val daemonJvmArgs = config.daemonJvmArgs
+    private val compilerExecutionStrategy = config.compilerExecutionStrategy
 
     private val log: KotlinLogger =
         TaskLoggers.get(taskPath)?.let { GradleKotlinLogger(it).apply { debug("Using '$taskPath' logger") } }
@@ -155,8 +158,7 @@ internal class GradleKotlinCompilerWork @Inject constructor(
             kotlinDebug { "$taskPath Kotlin compiler args: ${compilerArgs.joinToString(" ")}" }
         }
 
-        val executionStrategy = kotlinCompilerExecutionStrategy()
+        if (compilerExecutionStrategy == KotlinCompilerExecutionStrategy.DAEMON) {
-        if (executionStrategy == DAEMON_EXECUTION_STRATEGY) {
             val daemonExitCode = compileWithDaemon(messageCollector)
 
             if (daemonExitCode != null) {
@@ -167,7 +169,7 @@ internal class GradleKotlinCompilerWork @Inject constructor(
         }
 
         val isGradleDaemonUsed = System.getProperty("org.gradle.daemon")?.let(String::toBoolean)
-        return if (executionStrategy == IN_PROCESS_EXECUTION_STRATEGY || isGradleDaemonUsed == false) {
+        return if (compilerExecutionStrategy == KotlinCompilerExecutionStrategy.IN_PROCESS || isGradleDaemonUsed == false) {
             compileInProcess(messageCollector)
         } else {
             compileOutOfProcess()
@@ -242,7 +244,7 @@ internal class GradleKotlinCompilerWork @Inject constructor(
         } catch (e: RemoteException) {
             log.warn("Unable to clear jar cache after compilation, maybe daemon is already down: $e")
         }
-        log.logFinish(DAEMON_EXECUTION_STRATEGY)
+        log.logFinish(KotlinCompilerExecutionStrategy.DAEMON)
         return exitCode
     }
 
@@ -364,7 +366,7 @@ internal class GradleKotlinCompilerWork @Inject constructor(
             stream,
             exitCode
         )
-        log.logFinish(IN_PROCESS_EXECUTION_STRATEGY)
+        log.logFinish(KotlinCompilerExecutionStrategy.IN_PROCESS)
         return exitCode
     }
 

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/compilerRunner/reportUtils.kt

@@ -26,6 +26,7 @@ import org.jetbrains.kotlin.config.KotlinCompilerVersion
 import org.jetbrains.kotlin.daemon.client.DaemonReportingTargets
 import org.jetbrains.kotlin.daemon.client.launchProcessWithFallback
 import org.jetbrains.kotlin.gradle.logging.GradleKotlinLogger
+import org.jetbrains.kotlin.gradle.tasks.KotlinCompilerExecutionStrategy
 import org.jetbrains.org.objectweb.asm.ClassReader
 import org.jetbrains.org.objectweb.asm.ClassVisitor
 import org.jetbrains.org.objectweb.asm.FieldVisitor
@@ -129,7 +130,7 @@ internal fun runToolInSeparateProcess(
     readErrThread.join()
 
     val exitCode = process.waitFor()
-    logger.logFinish(OUT_OF_PROCESS_EXECUTION_STRATEGY)
+    logger.logFinish(KotlinCompilerExecutionStrategy.OUT_OF_PROCESS)
     return exitCodeFromProcessExitCode(logger, exitCode)
 }
 
@@ -171,7 +172,7 @@ private fun createLoggingMessageCollector(log: KotlinLogger): MessageCollector =
     }
 }
 
-internal fun KotlinLogger.logFinish(strategy: String) {
+internal fun KotlinLogger.logFinish(strategy: KotlinCompilerExecutionStrategy) {
     debug("Finished executing kotlin compiler using $strategy strategy")
 }
 

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/internal/kapt/KaptWithKotlincTask.kt

@@ -122,7 +122,8 @@ abstract class KaptWithKotlincTask @Inject constructor(
             taskProvider.get(),
             defaultKotlinJavaToolchain.get().currentJvmJdkToolsJar.orNull,
             normalizedKotlinDaemonJvmArguments.orNull,
-            metrics.get()
+            metrics.get(),
+            compilerExecutionStrategy.get(),
         )
         compilerRunner.runJvmCompilerAsync(
             sourcesToCompile = emptyList(),

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/KotlinProperties.kt

@@ -23,10 +23,7 @@ import org.jetbrains.kotlin.gradle.targets.js.dukat.ExternalsOutputFormat
 import org.jetbrains.kotlin.gradle.targets.js.dukat.ExternalsOutputFormat.Companion.externalsOutputFormatProperty
 import org.jetbrains.kotlin.gradle.targets.js.webpack.WebpackMajorVersion
 import org.jetbrains.kotlin.gradle.targets.native.DisabledNativeTargetsReporter
-import org.jetbrains.kotlin.gradle.tasks.AbstractKotlinCompile
+import org.jetbrains.kotlin.gradle.tasks.*
-import org.jetbrains.kotlin.gradle.tasks.CompileUsingKotlinDaemon
-import org.jetbrains.kotlin.gradle.tasks.Kotlin2JsCompile
-import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 import org.jetbrains.kotlin.gradle.utils.SingleWarningPerBuild
 import org.jetbrains.kotlin.konan.target.KonanTarget
 import org.jetbrains.kotlin.konan.target.presetName
@@ -59,9 +56,12 @@ internal fun PropertiesProvider.mapKotlinDaemonProperties(task: CompileUsingKotl
     kotlinDaemonJvmArgs?.let {
         task.kotlinDaemonJvmArguments.set(it.split("\\s+".toRegex()))
     }
+    if (!task.compilerExecutionStrategy.isPresent) {
+        task.compilerExecutionStrategy.set(kotlinCompilerExecutionStrategy)
+    }
 }
 
- internal class PropertiesProvider private constructor(private val project: Project) {
+internal class PropertiesProvider private constructor(private val project: Project) {
     private val localProperties: Properties by lazy {
         Properties().apply {
             val localPropertiesFile = project.rootProject.file("local.properties")
@@ -159,10 +159,10 @@ internal fun PropertiesProvider.mapKotlinDaemonProperties(task: CompileUsingKotl
     val mppStabilityNoWarn: Boolean?
         get() = booleanProperty(KotlinMultiplatformPlugin.STABILITY_NOWARN_FLAG)
 
-     val wasmStabilityNoWarn: Boolean
+    val wasmStabilityNoWarn: Boolean
-         get() = booleanProperty("kotlin.wasm.stability.nowarn") ?: false
+        get() = booleanProperty("kotlin.wasm.stability.nowarn") ?: false
 
-     val ignoreDisabledNativeTargets: Boolean?
+    val ignoreDisabledNativeTargets: Boolean?
         get() = booleanProperty(DisabledNativeTargetsReporter.DISABLE_WARNING_PROPERTY_NAME)
 
     val ignoreIncorrectNativeDependencies: Boolean?
@@ -358,6 +358,14 @@ internal fun PropertiesProvider.mapKotlinDaemonProperties(task: CompileUsingKotl
     val kotlinDaemonJvmArgs: String?
         get() = property("kotlin.daemon.jvmargs")
 
+    val kotlinCompilerExecutionStrategy: KotlinCompilerExecutionStrategy
+        get() {
+            val gradleProperty = property("kotlin.compiler.execution.strategy")
+            // system property is for backward compatibility
+            val value = (gradleProperty ?: System.getProperty("kotlin.compiler.execution.strategy"))?.toLowerCase()
+            return KotlinCompilerExecutionStrategy.fromProperty(value)
+        }
+
     private fun propertyWithDeprecatedVariant(propName: String, deprecatedPropName: String): String? {
         val deprecatedProperty = property(deprecatedPropName)
         if (deprecatedProperty != null) {

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/tasks/KotlinCompileCommon.kt

@@ -90,6 +90,7 @@ abstract class KotlinCompileCommon @Inject constructor(
                     null,
                     normalizedKotlinDaemonJvmArguments.orNull,
                     metrics.get(),
+                    compilerExecutionStrategy.get(),
                     workerExecutor
                 )
             }

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/tasks/Tasks.kt

@@ -322,7 +322,8 @@ abstract class AbstractKotlinCompile<T : CommonCompilerArguments> : AbstractKotl
                     it,
                     null,
                     normalizedKotlinDaemonJvmArguments.orNull,
-                    metrics.get()
+                    metrics.get(),
+                    compilerExecutionStrategy.get(),
                 )
             }
         )
@@ -665,6 +666,7 @@ abstract class KotlinCompile @Inject constructor(
                     toolchain.currentJvmJdkToolsJar.orNull,
                     normalizedKotlinDaemonJvmArguments.orNull,
                     metrics.get(),
+                    compilerExecutionStrategy.get(),
                     workerExecutor
                 )
             })
@@ -993,6 +995,7 @@ abstract class Kotlin2JsCompile @Inject constructor(
                     null,
                     normalizedKotlinDaemonJvmArguments.orNull,
                     metrics.get(),
+                    compilerExecutionStrategy.get(),
                     workerExecutor
                 )
             }