Allow specifying additional JVM arguments for Kapt task

These arguments are only used when 'kapt.workers.isolation=process' mode
is used. It allows users to apply workaround for running kapt on newer
JDK version without waiting for a new Kotlin release

^KT-48450 Fixed

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

@@ -100,6 +100,64 @@ open class Kapt3WorkersIT : Kapt3IT() {
             }
         }
     }
+
+    @DisplayName("Additional Kapt jvm arguments are passed to the process")
+    @GradleTest
+    internal fun additionalJvmArgumentsArePassed(gradleVersion: GradleVersion) {
+        project("simple".withPrefix, gradleVersion) {
+            gradleProperties.append(
+                """
+                
+                kapt.workers.isolation = process
+                """.trimIndent()
+            )
+
+            buildGradle.append(
+                //language=Groovy
+                """
+                
+                tasks
+                    .withType(org.jetbrains.kotlin.gradle.internal.KaptWithoutKotlincTask.class)
+                    .configureEach {
+                        it.kaptProcessJvmArgs.addAll(['-Xmx64m', '-Duser.country=DE'])
+                    }
+                """.trimIndent()
+            )
+
+            build("assemble") {
+                assertOutputContains("Starting process 'Gradle Worker Daemon.*-Xmx64m.*-Duser.country=DE.*".toRegex())
+            }
+        }
+    }
+
+    @DisplayName("Warning is produced on additional Kapt jvm arguments and 'none' workers isolation mode")
+    @GradleTest
+    internal fun warningOnNoneIsolationModeAndAdditionalJvmArguments(gradleVersion: GradleVersion) {
+        project("simple".withPrefix, gradleVersion) {
+            gradleProperties.append(
+                """
+                
+                kapt.workers.isolation = none
+                """.trimIndent()
+            )
+
+            buildGradle.append(
+                //language=Groovy
+                """
+                
+                tasks
+                    .withType(org.jetbrains.kotlin.gradle.internal.KaptWithoutKotlincTask.class)
+                    .configureEach {
+                        it.kaptProcessJvmArgs.addAll(['-Xmx64m', '-Duser.country=DE'])
+                    }
+                """.trimIndent()
+            )
+
+            build("assemble") {
+                assertOutputContains("Kapt additional JVM arguments are ignored in 'NONE' workers isolation mode")
+            }
+        }
+    }
 }
 
 @DisplayName("Kapt with classloaders cache executing via workers ")

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

@@ -8,10 +8,11 @@ package org.jetbrains.kotlin.gradle.internal
 import org.gradle.api.file.ConfigurableFileCollection
 import org.gradle.api.file.FileCollection
 import org.gradle.api.model.ObjectFactory
+import org.gradle.api.provider.ListProperty
 import org.gradle.api.provider.Property
 import org.gradle.api.provider.ProviderFactory
 import org.gradle.api.tasks.*
-import org.gradle.api.tasks.incremental.IncrementalTaskInputs
+import org.gradle.kotlin.dsl.listProperty
 import org.gradle.process.CommandLineArgumentProvider
 import org.gradle.work.InputChanges
 import org.gradle.workers.IsolationMode
@@ -77,6 +78,9 @@ abstract class KaptWithoutKotlincTask @Inject constructor(
     @get:Internal
     internal val projectDir = project.projectDir
 
+    @get:Input
+    val kaptProcessJvmArgs: ListProperty<String> = objectFactory.listProperty<String>().convention(emptyList())
+
     private fun getAnnotationProcessorOptions(): Map<String, String> {
         val options = processorOptions.subpluginOptionsByPluginId[Kapt3GradleSubplugin.KAPT_SUBPLUGIN_ID] ?: return emptyMap()
 
@@ -195,13 +199,17 @@ abstract class KaptWithoutKotlincTask @Inject constructor(
                     // for tests
                     it.forkOptions.jvmArgs("-verbose:class")
                 }
+                kaptProcessJvmArgs.get().run { if (isNotEmpty()) it.forkOptions.jvmArgs(this) }
                 it.forkOptions.executable = defaultKotlinJavaToolchain.get()
                     .javaExecutable
                     .asFile.get()
                     .absolutePath
                 logger.info("Kapt worker classpath: ${it.classpath}")
             }
-            IsolationMode.NONE -> workerExecutor.noIsolation()
+            IsolationMode.NONE -> {
+                warnAdditionalJvmArgsAreNotUsed(isolationMode)
+                workerExecutor.noIsolation()
+            }
             IsolationMode.AUTO, IsolationMode.CLASSLOADER -> throw UnsupportedOperationException(
                 "Kapt worker compilation does not support class loader isolation. " +
                         "Please use either \"none\" or \"process\" in gradle.properties."
@@ -216,6 +224,12 @@ abstract class KaptWithoutKotlincTask @Inject constructor(
         }
     }
 
+    private fun warnAdditionalJvmArgsAreNotUsed(isolationMode: IsolationMode) {
+        if (kaptProcessJvmArgs.get().isNotEmpty()) {
+            logger.warn("Kapt additional JVM arguments are ignored in '${isolationMode.name}' workers isolation mode")
+        }
+    }
+
     internal fun getValue(propertyName: String): String? =
         if (isGradleVersionAtLeast(6, 5)) {
             providerFactory.gradleProperty(propertyName).forUseAtConfigurationTime().orNull