Adding possibility to skip params inheritance on daemon jvm options creation, refactoring appropriate api, using it to fix tests

compiler/rmi/kotlinr/src/org/jetbrains/kotlin/rmi/kotlinr/KotlinCompilerClient.kt

@@ -171,7 +171,7 @@ public object KotlinCompilerClient {
     public fun main(vararg args: String) {
         val compilerId = CompilerId()
         val daemonOptions = configureDaemonOptions()
-        val daemonLaunchingOptions = configureDaemonJVMOptions(true)
+        val daemonLaunchingOptions = configureDaemonJVMOptions(inheritMemoryLimits = true, inheritAdditionalProperties = true)
         val clientOptions = configureClientOptions()
         val filteredArgs = args.asIterable().filterExtractProps(compilerId, daemonOptions, daemonLaunchingOptions, clientOptions, prefix = COMPILE_DAEMON_CMDLINE_OPTIONS_PREFIX)
 

compiler/rmi/rmi-interface/src/org/jetbrains/kotlin/rmi/DaemonParams.kt

@@ -251,7 +251,11 @@ public data class CompilerId(
 public fun isDaemonEnabled(): Boolean = System.getProperty(COMPILE_DAEMON_ENABLED_PROPERTY) != null
 
 
-public fun configureDaemonJVMOptions(opts: DaemonJVMOptions, inheritMemoryLimits: Boolean, vararg additionalParams: String): DaemonJVMOptions {
+public fun configureDaemonJVMOptions(opts: DaemonJVMOptions,
+                                     vararg additionalParams: String,
+                                     inheritMemoryLimits: Boolean,
+                                     inheritAdditionalProperties: Boolean
+): DaemonJVMOptions {
     // note: sequence matters, explicit override in COMPILE_DAEMON_JVM_OPTIONS_PROPERTY should be done after inputArguments processing
     if (inheritMemoryLimits) {
         ManagementFactory.getRuntimeMXBean().inputArguments.filterExtractProps(opts.mappers, "-")
@@ -264,15 +268,23 @@ public fun configureDaemonJVMOptions(opts: DaemonJVMOptions, inheritMemoryLimits
                   .filterExtractProps(opts.mappers, "-", opts.restMapper))
     }
 
-    System.getProperty(COMPILE_DAEMON_LOG_PATH_PROPERTY)?.let { opts.jvmParams.add("D$COMPILE_DAEMON_LOG_PATH_PROPERTY=\"$it\"" ) }
     opts.jvmParams.addAll(additionalParams)
-    System.getProperty(KOTLIN_COMPILER_ENVIRONMENT_KEEPALIVE_PROPERTY)?.let { opts.jvmParams.add("D$KOTLIN_COMPILER_ENVIRONMENT_KEEPALIVE_PROPERTY") }
+    if (inheritAdditionalProperties) {
+        System.getProperty(COMPILE_DAEMON_LOG_PATH_PROPERTY)?.let { opts.jvmParams.add("D$COMPILE_DAEMON_LOG_PATH_PROPERTY=\"$it\"") }
+        System.getProperty(KOTLIN_COMPILER_ENVIRONMENT_KEEPALIVE_PROPERTY)?.let { opts.jvmParams.add("D$KOTLIN_COMPILER_ENVIRONMENT_KEEPALIVE_PROPERTY") }
+    }
     return opts
 }
 
 
-public fun configureDaemonJVMOptions(inheritMemoryLimits: Boolean, vararg additionalParams: String): DaemonJVMOptions =
-        configureDaemonJVMOptions(DaemonJVMOptions(), inheritMemoryLimits = inheritMemoryLimits, additionalParams = *additionalParams)
+public fun configureDaemonJVMOptions(vararg additionalParams: String,
+                                     inheritMemoryLimits: Boolean,
+                                     inheritAdditionalProperties: Boolean
+): DaemonJVMOptions =
+        configureDaemonJVMOptions(DaemonJVMOptions(),
+                                  additionalParams = *additionalParams,
+                                  inheritMemoryLimits = inheritMemoryLimits,
+                                  inheritAdditionalProperties = inheritAdditionalProperties)
 
 
 public fun configureDaemonOptions(opts: DaemonOptions): DaemonOptions {

compiler/tests/org/jetbrains/kotlin/daemon/CompilerDaemonTest.kt

@@ -77,8 +77,8 @@ public class CompilerDaemonTest : KotlinIntegrationTestBase() {
 
         val logFile = createTempFile("kotlin-daemon-test.", ".log")
 
-        val daemonJVMOptions = configureDaemonJVMOptions(false,
-                                                         "D$COMPILE_DAEMON_LOG_PATH_PROPERTY=\"${logFile.absolutePath}\"")
+        val daemonJVMOptions = configureDaemonJVMOptions("D$COMPILE_DAEMON_LOG_PATH_PROPERTY=\"${logFile.absolutePath}\"",
+                                                         inheritMemoryLimits = false, inheritAdditionalProperties = false)
         var daemonShotDown = false
 
         try {
@@ -118,7 +118,7 @@ public class CompilerDaemonTest : KotlinIntegrationTestBase() {
         val backupJvmOptions = System.getProperty(COMPILE_DAEMON_JVM_OPTIONS_PROPERTY)
         try {
             System.setProperty(COMPILE_DAEMON_JVM_OPTIONS_PROPERTY, "-aaa,-bbb\\,ccc,-ddd,-Xmx200m,-XX:MaxPermSize=10k,-XX:ReservedCodeCacheSize=100,-xxx\\,yyy")
-            val opts = configureDaemonJVMOptions(inheritMemoryLimits = false)
+            val opts = configureDaemonJVMOptions(inheritMemoryLimits = false, inheritAdditionalProperties = false)
             TestCase.assertEquals("200m", opts.maxMemory)
             TestCase.assertEquals("10k", opts.maxPermSize)
             TestCase.assertEquals("100", opts.reservedCodeCacheSize)
@@ -158,11 +158,12 @@ public class CompilerDaemonTest : KotlinIntegrationTestBase() {
         val logFile1 = createTempFile("kotlin-daemon1-test", ".log")
         val logFile2 = createTempFile("kotlin-daemon2-test", ".log")
         val daemonJVMOptions1 =
-                configureDaemonJVMOptions(false,
-                                          "D$COMPILE_DAEMON_LOG_PATH_PROPERTY=\"${logFile1.absolutePath}\"")
+                configureDaemonJVMOptions("D$COMPILE_DAEMON_LOG_PATH_PROPERTY=\"${logFile1.absolutePath}\"",
+                                          inheritMemoryLimits = false, inheritAdditionalProperties = false)
+
         val daemonJVMOptions2 =
-                configureDaemonJVMOptions(false,
-                                          "D$COMPILE_DAEMON_LOG_PATH_PROPERTY=\"${logFile2.absolutePath}\"")
+                configureDaemonJVMOptions("D$COMPILE_DAEMON_LOG_PATH_PROPERTY=\"${logFile2.absolutePath}\"",
+                                          inheritMemoryLimits = false, inheritAdditionalProperties = false)
 
         TestCase.assertTrue(logFile1.length() == 0L && logFile2.length() == 0L)
 
@@ -258,7 +259,7 @@ public class CompilerDaemonTest : KotlinIntegrationTestBase() {
         val flagFile = createTempFile(getTestName(true), ".alive")
         flagFile.deleteOnExit()
         val daemonOptions = DaemonOptions(runFilesPath = File(tmpdir, getTestName(true)).absolutePath, clientAliveFlagPath = flagFile.absolutePath)
-        val daemonJVMOptions = configureDaemonJVMOptions(false)
+        val daemonJVMOptions = configureDaemonJVMOptions(inheritMemoryLimits = false, inheritAdditionalProperties = false)
         val daemon = KotlinCompilerClient.connectToCompileService(compilerId, daemonJVMOptions, daemonOptions, DaemonReportingTargets(out = System.err), autostart = true, checkId = true)
         TestCase.assertNotNull("failed to connect daemon", daemon)
 

jps-plugin/src/org/jetbrains/kotlin/compilerRunner/KotlinCompilerRunner.kt

@@ -139,7 +139,7 @@ public object KotlinCompilerRunner {
                 val libPath = CompilerRunnerUtil.getLibPath(environment.kotlinPaths, messageCollector)
                 val compilerId = CompilerId.makeCompilerId(File(libPath, "kotlin-compiler.jar"))
                 val daemonOptions = configureDaemonOptions()
-                val daemonJVMOptions = configureDaemonJVMOptions(true)
+                val daemonJVMOptions = configureDaemonJVMOptions(inheritMemoryLimits = true, inheritAdditionalProperties = true)
                 // the property should be set by default for daemon builds to avoid parallel building problems
                 // but it cannot be currently set by default globally, because it seems breaks many tests
                 // TODO: find out how to get rid of the property and make it the default behavior