remove execOperation for compiler workers

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

@@ -6,7 +6,6 @@
 package org.jetbrains.kotlin.compilerRunner
 
 import org.gradle.api.Task
-import org.gradle.workers.ForkMode
 import org.gradle.workers.IsolationMode
 import org.gradle.workers.WorkerExecutor
 import org.jetbrains.kotlin.gradle.logging.kotlinDebug

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

@@ -170,6 +170,7 @@ internal open class GradleCompilerRunner(protected val task: Task) {
 
         @Volatile
         private var cachedGradle = WeakReference<Gradle>(null)
+
         @Volatile
         private var cachedModulesInfo: IncrementalModuleInfo? = null
 

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

@@ -17,7 +17,6 @@ import org.jetbrains.kotlin.gradle.report.BuildReportMode
 import org.jetbrains.kotlin.gradle.report.TaskExecutionResult
 import org.jetbrains.kotlin.gradle.tasks.clearLocalState
 import org.jetbrains.kotlin.gradle.tasks.throwGradleExceptionIfError
-import org.jetbrains.kotlin.gradle.utils.isGradleVersionAtLeast
 import org.jetbrains.kotlin.gradle.utils.stackTraceAsString
 import org.jetbrains.kotlin.incremental.ChangedFiles
 import org.jetbrains.kotlin.incremental.IncrementalModuleInfo
@@ -34,13 +33,13 @@ internal class ProjectFilesForCompilation(
     val projectRootFile: File,
     val clientIsAliveFlagFile: File,
     val sessionFlagFile: File,
-    val project: Project
+    val buildDir: File
 ) : Serializable {
     constructor(project: Project) : this(
         projectRootFile = project.rootProject.projectDir,
         clientIsAliveFlagFile = GradleCompilerRunner.getOrCreateClientFlagFile(project),
         sessionFlagFile = GradleCompilerRunner.getOrCreateSessionFlagFile(project),
-        project = project
+        buildDir = project.buildDir
     )
 
     companion object {
@@ -100,7 +99,7 @@ internal class GradleKotlinCompilerWork @Inject constructor(
     private val buildReportMode = config.buildReportMode
     private val kotlinScriptExtensions = config.kotlinScriptExtensions
     private val allWarningsAsErrors = config.allWarningsAsErrors
-    private val project = config.projectFiles.project
+    private val buildDir = config.projectFiles.buildDir
 
     private val log: KotlinLogger =
         TaskLoggers.get(taskPath)?.let { GradleKotlinLogger(it).apply { debug("Using '$taskPath' logger") } }
@@ -301,13 +300,7 @@ internal class GradleKotlinCompilerWork @Inject constructor(
         clearLocalState(outputFiles, log, reason = "out-of-process execution strategy is non-incremental")
 
         return try {
-            if (isGradleVersionAtLeast(6, 0)) {
+            runToolInSeparateProcess(compilerArgs, compilerClassName, compilerFullClasspath, log, buildDir)
-                val execResult =
-                    runToolInSeparateProcessForGradle6AndMore(compilerArgs, compilerClassName, compilerFullClasspath, project)
-                exitCodeFromProcessExitCode(log, execResult.exitValue)
-            } else {
-                runToolInSeparateProcess(compilerArgs, compilerClassName, compilerFullClasspath, log, project.buildDir)
-            }
         } finally {
             reportExecutionResultIfNeeded {
                 TaskExecutionResult(

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

@@ -16,7 +16,8 @@
 
 package org.jetbrains.kotlin.compilerRunner
 
-import org.gradle.api.Project
+import org.gradle.api.file.FileCollection
+import org.gradle.process.ExecOperations
 import org.gradle.process.ExecResult
 import org.jetbrains.kotlin.cli.common.ExitCode
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageLocation
@@ -86,21 +87,6 @@ internal fun loadCompilerVersion(compilerClasspath: List<File>): String {
     return result ?: "<unknown>"
 }
 
-internal fun runToolInSeparateProcessForGradle6AndMore(
-    argsArray: Array<String>,
-    compilerClassName: String,
-    classpath: List<File>,
-    project: Project
-): ExecResult {
-    val gradleExecutionOperation = project.objects.newInstance(GradleExecOperationsHolder::class.java)
-    val compilationArguments = writeArgumentsToFile(project.buildDir, argsArray)
-    return gradleExecutionOperation.execOperation.javaexec {
-        it.classpath = project.files(classpath)
-        it.args = listOf("@${compilationArguments.absolutePath}")
-        it.main = compilerClassName
-    }
-}
-
 internal fun runToolInSeparateProcess(
     argsArray: Array<String>,
     compilerClassName: String,

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

@@ -26,13 +26,11 @@ import org.gradle.api.tasks.TaskAction
 import org.jetbrains.kotlin.cli.common.arguments.K2JSDceArguments
 import org.jetbrains.kotlin.cli.js.dce.K2JSDce
 import org.jetbrains.kotlin.compilerRunner.runToolInSeparateProcess
-import org.jetbrains.kotlin.compilerRunner.runToolInSeparateProcessForGradle6AndMore
 import org.jetbrains.kotlin.gradle.dsl.KotlinJsDce
 import org.jetbrains.kotlin.gradle.dsl.KotlinJsDceOptions
 import org.jetbrains.kotlin.gradle.dsl.KotlinJsDceOptionsImpl
 import org.jetbrains.kotlin.gradle.logging.GradleKotlinLogger
 import org.jetbrains.kotlin.gradle.utils.canonicalPathWithoutExtension
-import org.jetbrains.kotlin.gradle.utils.isGradleVersionAtLeast
 import java.io.File
 
 @CacheableTask
@@ -85,23 +83,15 @@ open class KotlinJsDce : AbstractKotlinCompileTool<K2JSDceArguments>(), KotlinJs
         val log = GradleKotlinLogger(logger)
         val allArgs = argsArray + outputDirArgs + inputFiles
 
-        if (isGradleVersionAtLeast(6,0)) {
+        val exitCode = runToolInSeparateProcess(
-            runToolInSeparateProcessForGradle6AndMore(
+            allArgs,
-                allArgs,
+            K2JSDce::class.java.name,
-                K2JSDce::class.java.name,
+            computedCompilerClasspath,
-                computedCompilerClasspath,
+            log,
-                project
+            project.buildDir
-            ).rethrowFailure()
+        )
-        } else {
+        throwGradleExceptionIfError(exitCode)
-            val exitCode = runToolInSeparateProcess(
+
-                allArgs,
-                K2JSDce::class.java.name,
-                computedCompilerClasspath,
-                log,
-                project.buildDir
-            )
-            throwGradleExceptionIfError(exitCode)
-        }
     }
 
     private fun isDceCandidate(file: File): Boolean {