Migrate to the actual workers api available from Gradle 5.6.

Old api was removed in Gradle 7 and causes build crashes.

KT-44949 In Progress

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

@@ -1,27 +1,43 @@
 /*
- * Copyright 2010-2018 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
  * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
  */
 
 package org.jetbrains.kotlin.compilerRunner
 
-import org.gradle.workers.IsolationMode
+import org.gradle.api.provider.Property
+import org.gradle.workers.WorkAction
+import org.gradle.workers.WorkParameters
 import org.gradle.workers.WorkerExecutor
 import org.jetbrains.kotlin.gradle.logging.kotlinDebug
 import org.jetbrains.kotlin.gradle.tasks.GradleCompileTaskProvider
 
+/**
+ * Uses Gradle worker api to run kotlin compilation.
+ */
 internal class GradleCompilerRunnerWithWorkers(
     taskProvider: GradleCompileTaskProvider,
-    private val workersExecutor: WorkerExecutor
+    private val workerExecutor: WorkerExecutor
 ) : GradleCompilerRunner(taskProvider) {
-
     override fun runCompilerAsync(workArgs: GradleKotlinCompilerWorkArguments) {
         loggerProvider.kotlinDebug { "Starting Kotlin compiler work from task '${pathProvider}'" }
-        // todo: write tests with Workers enabled;
+
-        workersExecutor.submit(GradleKotlinCompilerWork::class.java) { config ->
+        val workQueue = workerExecutor.noIsolation()
-            config.isolationMode = IsolationMode.NONE
+        workQueue.submit(GradleKotlinCompilerWorkAction::class.java) {
-            config.params(workArgs)
+            it.compilerWorkArguments.set(workArgs)
         }
     }
 
+    internal abstract class GradleKotlinCompilerWorkAction
+        : WorkAction<GradleKotlinCompilerWorkParameters> {
+        override fun execute() {
+            GradleKotlinCompilerWork(
+                parameters.compilerWorkArguments.get()
+            ).run()
+        }
+    }
+
+    internal interface GradleKotlinCompilerWorkParameters : WorkParameters {
+        val compilerWorkArguments: Property<GradleKotlinCompilerWorkArguments>
+    }
 }

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

@@ -5,9 +5,13 @@
 
 package org.jetbrains.kotlin.gradle.internal
 
+import org.gradle.api.file.ConfigurableFileCollection
+import org.gradle.api.provider.Property
 import org.gradle.api.tasks.*
 import org.gradle.api.tasks.incremental.IncrementalTaskInputs
 import org.gradle.workers.IsolationMode
+import org.gradle.workers.WorkAction
+import org.gradle.workers.WorkParameters
 import org.gradle.workers.WorkerExecutor
 import org.jetbrains.kotlin.gradle.internal.Kapt3GradleSubplugin.Companion.KAPT_WORKER_DEPENDENCIES_CONFIGURATION_NAME
 import org.jetbrains.kotlin.gradle.internal.kapt.incremental.KaptIncrementalChanges
@@ -15,7 +19,6 @@ import org.jetbrains.kotlin.gradle.plugin.KotlinAndroidPluginWrapper
 import org.jetbrains.kotlin.gradle.tasks.CompilerPluginOptions
 import org.jetbrains.kotlin.gradle.tasks.findKotlinStdlibClasspath
 import org.jetbrains.kotlin.gradle.tasks.findToolsJar
-import org.jetbrains.kotlin.gradle.utils.getValue
 import org.jetbrains.kotlin.gradle.utils.isGradleVersionAtLeast
 import org.jetbrains.kotlin.utils.PathUtil
 import java.io.File
@@ -121,20 +124,50 @@ abstract class KaptWithoutKotlincTask @Inject constructor(private val workerExec
 
         val kaptClasspath = kaptJars + kotlinStdlibClasspath
 
-        workerExecutor.submit(KaptExecution::class.java) { config ->
+        //TODO for gradle < 6.5
-            //TODO for gradle < 6.5
+        val isolationModeStr = getValue("kapt.workers.isolation") ?: "none"
-            val isolationModeStr = getValue("kapt.workers.isolation") ?: "none"
+        val isolationMode = when (isolationModeStr.toLowerCase()) {
-            config.isolationMode = when (isolationModeStr.toLowerCase()) {
+            "process" -> IsolationMode.PROCESS
-                "process" -> IsolationMode.PROCESS
+            "none" -> IsolationMode.NONE
-                "none" -> IsolationMode.NONE
+            else -> IsolationMode.NONE
-                else -> IsolationMode.NONE
+        }
+        val toolsJarURLSpec = findToolsJar()?.toURI()?.toURL()?.toString().orEmpty()
+
+        submitWork(
+            isolationMode,
+            optionsForWorker,
+            toolsJarURLSpec,
+            kaptClasspath
+        )
+    }
+
+    private fun submitWork(
+        isolationMode: IsolationMode,
+        optionsForWorker: KaptOptionsForWorker,
+        toolsJarURLSpec: String,
+        kaptClasspath: List<File>
+    ) {
+        val workQueue = when (isolationMode) {
+            IsolationMode.PROCESS -> workerExecutor.processIsolation {
+                if (getValue("kapt.workers.log.classloading") == "true") {
+                    // for tests
+                    it.forkOptions.jvmArgs("-verbose:class")
+                }
+                logger.info("Kapt worker classpath: ${it.classpath}")
             }
-            config.params(optionsForWorker, findToolsJar()?.toURI()?.toURL()?.toString().orEmpty(), kaptClasspath)
+            IsolationMode.CLASSLOADER -> workerExecutor.classLoaderIsolation() {
-            if (getValue("kapt.workers.log.classloading") == "true") {
+                logger.info("Kapt worker classpath: ${it.classpath}")
-                // for tests
-                config.forkOptions.jvmArgs("-verbose:class")
             }
-            logger.info("Kapt worker classpath: ${config.classpath}")
+            IsolationMode.NONE -> workerExecutor.noIsolation()
+            IsolationMode.AUTO -> throw UnsupportedOperationException(
+                "Kapt worker compilation does not support $isolationMode"
+            )
+        }
+
+        workQueue.submit(KaptExecutionWorkAction::class.java) {
+            it.workerOptions.set(optionsForWorker)
+            it.toolsJarURLSpec.set(toolsJarURLSpec)
+            it.kaptClasspath.setFrom(kaptClasspath)
         }
     }
 
@@ -145,6 +178,21 @@ abstract class KaptWithoutKotlincTask @Inject constructor(private val workerExec
             project.findProperty(propertyName) as String?
         }
 
+    internal interface KaptWorkParameters : WorkParameters {
+        val workerOptions: Property<KaptOptionsForWorker>
+        val toolsJarURLSpec: Property<String>
+        val kaptClasspath: ConfigurableFileCollection
+    }
+
+    internal abstract class KaptExecutionWorkAction : WorkAction<KaptWorkParameters> {
+        override fun execute() {
+            KaptExecution(
+                parameters.workerOptions.get(),
+                parameters.toolsJarURLSpec.get(),
+                parameters.kaptClasspath.toList()
+            ).run()
+        }
+    }
 }
 
 
@@ -232,7 +280,7 @@ private class KaptExecution @Inject constructor(
     }
 }
 
-private data class KaptOptionsForWorker(
+internal data class KaptOptionsForWorker(
     val projectBaseDir: File,
     val compileClasspath: List<File>,
     val javaSourceRoots: List<File>,

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/targets/js/ir/KotlinJsIrLinkWithWorkers.kt

@@ -17,5 +17,9 @@ internal open class KotlinJsIrLinkWithWorkers
 constructor(
     private val workerExecutor: WorkerExecutor
 ) : KotlinJsIrLink() {
-    override fun compilerRunner() = GradleCompilerRunnerWithWorkers(GradleCompileTaskProvider(this), workerExecutor)
+    override fun compilerRunner() =
+        GradleCompilerRunnerWithWorkers(
+            GradleCompileTaskProvider(this),
+            workerExecutor
+        )
 }

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

@@ -623,7 +623,11 @@ internal open class KotlinCompileWithWorkers @Inject constructor(
     private val workerExecutor: WorkerExecutor
 ) : KotlinCompile() {
 
-    override fun compilerRunner() = GradleCompilerRunnerWithWorkers(GradleCompileTaskProvider(this), workerExecutor)
+    override fun compilerRunner() =
+        GradleCompilerRunnerWithWorkers(
+            GradleCompileTaskProvider(this),
+            workerExecutor
+        )
 }
 
 @CacheableTask
@@ -631,14 +635,22 @@ internal open class Kotlin2JsCompileWithWorkers @Inject constructor(
     private val workerExecutor: WorkerExecutor
 ) : Kotlin2JsCompile() {
 
-    override fun compilerRunner() = GradleCompilerRunnerWithWorkers(GradleCompileTaskProvider(this), workerExecutor)
+    override fun compilerRunner() =
+        GradleCompilerRunnerWithWorkers(
+            GradleCompileTaskProvider(this),
+            workerExecutor
+        )
 }
 
 @CacheableTask
 internal open class KotlinCompileCommonWithWorkers @Inject constructor(
     private val workerExecutor: WorkerExecutor
 ) : KotlinCompileCommon() {
-    override fun compilerRunner() = GradleCompilerRunnerWithWorkers(GradleCompileTaskProvider(this), workerExecutor)
+    override fun compilerRunner() =
+        GradleCompilerRunnerWithWorkers(
+            GradleCompileTaskProvider(this),
+            workerExecutor
+        )
 }
 
 @CacheableTask