Make JDK classpath roots configuration explicit...

instead of relying on the "configuration files" parameter.
(in the process of migration from KotlinCoreEnvironment).

benchmarks/src/org/jetbrains/kotlin/benchmarks/AbstractSimpleFileBenchmark.kt

@@ -19,6 +19,7 @@ import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector
 import org.jetbrains.kotlin.cli.jvm.compiler.*
 import org.jetbrains.kotlin.cli.jvm.config.addJvmClasspathRoot
+import org.jetbrains.kotlin.cli.jvm.config.configureJdkClasspathRoots
 import org.jetbrains.kotlin.config.*
 import org.jetbrains.kotlin.context.SimpleGlobalContext
 import org.jetbrains.kotlin.context.withModule
@@ -71,6 +72,7 @@ private fun newConfiguration(useNewInference: Boolean): CompilerConfiguration {
     configuration.put(CLIConfigurationKeys.INTELLIJ_PLUGIN_ROOT, "../compiler/cli/cli-common/resources")
     configuration.addJvmClasspathRoot(JDK_PATH)
     configuration.addJvmClasspathRoot(RUNTIME_JAR)
+    configuration.configureJdkClasspathRoots()
     configuration.put(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, MessageCollector.NONE)
 
     val newInferenceState = if (useNewInference) LanguageFeature.State.ENABLED else LanguageFeature.State.DISABLED

compiler/android-tests/tests/org/jetbrains/kotlin/android/tests/CodegenTestsOnAndroidGenerator.kt

@@ -12,6 +12,7 @@ import com.intellij.openapi.util.io.FileUtilRt
 import org.jetbrains.kotlin.cli.common.output.writeAllTo
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
+import org.jetbrains.kotlin.cli.jvm.config.configureJdkClasspathRoots
 import org.jetbrains.kotlin.codegen.CodegenTestFiles
 import org.jetbrains.kotlin.codegen.GenerationUtils
 import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime
@@ -215,7 +216,9 @@ class CodegenTestsOnAndroidGenerator private constructor(private val pathManager
             val disposable = Disposer.newDisposable()
             val environment = KotlinCoreEnvironment.createForTests(
                 disposable,
-                configuration.copy().apply { put(CommonConfigurationKeys.MODULE_NAME, "android-module-" + currentModuleIndex++) },
+                configuration.copy().apply {
+                    put(CommonConfigurationKeys.MODULE_NAME, "android-module-" + currentModuleIndex++)
+                },
                 EnvironmentConfigFiles.JVM_CONFIG_FILES
             )
 

compiler/builtins-serializer/src/org/jetbrains/kotlin/serialization/builtins/BuiltInsSerializer.kt

@@ -15,6 +15,7 @@ import org.jetbrains.kotlin.cli.common.config.addKotlinSourceRoots
 import org.jetbrains.kotlin.cli.common.messages.*
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
+import org.jetbrains.kotlin.cli.jvm.config.configureJdkClasspathRoots
 import org.jetbrains.kotlin.cli.jvm.config.addJvmClasspathRoots
 import org.jetbrains.kotlin.cli.metadata.MetadataSerializer
 import org.jetbrains.kotlin.config.CommonConfigurationKeys
@@ -49,6 +50,7 @@ class BuiltInsSerializer(dependOnOldBuiltIns: Boolean) : MetadataSerializer(Buil
 
                 addKotlinSourceRoots(srcDirs.map { it.path })
                 addJvmClasspathRoots(extraClassPath)
+                configureJdkClasspathRoots()
 
                 put(CLIConfigurationKeys.METADATA_DESTINATION_DIRECTORY, destDir)
                 put(CommonConfigurationKeys.MODULE_NAME, "module for built-ins serialization")

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/K2JVMCompiler.kt

@@ -35,6 +35,7 @@ import org.jetbrains.kotlin.cli.jvm.compiler.*
 import org.jetbrains.kotlin.cli.jvm.compiler.pipeline.compileModulesUsingFrontendIrAndLightTree
 import org.jetbrains.kotlin.cli.jvm.compiler.pipeline.createProjectEnvironment
 import org.jetbrains.kotlin.cli.jvm.config.ClassicFrontendSpecificJvmConfigurationKeys
+import org.jetbrains.kotlin.cli.jvm.config.configureJdkClasspathRoots
 import org.jetbrains.kotlin.codegen.CompilationException
 import org.jetbrains.kotlin.config.*
 import org.jetbrains.kotlin.incremental.components.ExpectActualTracker
@@ -83,6 +84,7 @@ class K2JVMCompiler : CLICompiler<K2JVMCompilerArguments>() {
             (arguments.script || arguments.expression != null || arguments.freeArgs.isEmpty())
         ) {
             configuration.configureContentRootsFromClassPath(arguments)
+            configuration.configureJdkClasspathRoots()
 
             // script or repl
             if (arguments.script && arguments.freeArgs.isEmpty()) {
@@ -123,6 +125,8 @@ class K2JVMCompiler : CLICompiler<K2JVMCompilerArguments>() {
 
             val chunk = moduleChunk.modules
             configuration.configureSourceRoots(chunk, buildFile)
+            // should be called after configuring jdk home from build file
+            configuration.configureJdkClasspathRoots()
 
             if (configuration.getBoolean(CommonConfigurationKeys.USE_FIR) && arguments.useFirLT /* TODO: consider storing in the configuration instead of using args here directly */) {
                 val projectEnvironment =

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinCoreEnvironment.kt

@@ -107,7 +107,7 @@ import java.util.zip.ZipFile
 
 class KotlinCoreEnvironment private constructor(
     val projectEnvironment: ProjectEnvironment,
-    private val initialConfiguration: CompilerConfiguration,
+    val configuration: CompilerConfiguration,
     configFiles: EnvironmentConfigFiles
 ) {
 
@@ -195,8 +195,6 @@ class KotlinCoreEnvironment private constructor(
     private val classpathRootsResolver: ClasspathRootsResolver
     private val initialRoots = ArrayList<JavaRoot>()
 
-    val configuration: CompilerConfiguration = initialConfiguration.apply { setupJdkClasspathRoots(configFiles) }.copy()
-
     init {
         projectEnvironment.configureProjectEnvironment(configuration, configFiles)
         val project = projectEnvironment.project
@@ -756,30 +754,5 @@ class KotlinCoreEnvironment private constructor(
                 PsiElementFinder.EP.getPoint(project).registerExtension(PsiElementFinderImpl(this))
             }
         }
-
-        private fun CompilerConfiguration.setupJdkClasspathRoots(configFiles: EnvironmentConfigFiles) {
-            if (getBoolean(JVMConfigurationKeys.NO_JDK)) return
-
-            val jvmTarget = configFiles == EnvironmentConfigFiles.JVM_CONFIG_FILES
-            if (!jvmTarget) return
-
-            val jdkHome = get(JVMConfigurationKeys.JDK_HOME)
-            val (javaRoot, classesRoots) = if (jdkHome == null) {
-                val javaHome = File(System.getProperty("java.home"))
-                put(JVMConfigurationKeys.JDK_HOME, javaHome)
-
-                javaHome to PathUtil.getJdkClassesRootsFromCurrentJre()
-            } else {
-                jdkHome to PathUtil.getJdkClassesRoots(jdkHome)
-            }
-
-            if (!CoreJrtFileSystem.isModularJdk(javaRoot)) {
-                if (classesRoots.isEmpty()) {
-                    report(ERROR, "No class roots are found in the JDK path: $javaRoot")
-                } else {
-                    addJvmSdkRoots(classesRoots)
-                }
-            }
-        }
     }
 }

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/config/JvmContentRoots.kt

@@ -20,7 +20,12 @@ import com.intellij.openapi.vfs.VirtualFile
 import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
 import org.jetbrains.kotlin.cli.common.config.ContentRoot
 import org.jetbrains.kotlin.cli.common.config.KotlinSourceRoot
+import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
+import org.jetbrains.kotlin.cli.jvm.compiler.report
+import org.jetbrains.kotlin.cli.jvm.modules.CoreJrtFileSystem
 import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.config.JVMConfigurationKeys
+import org.jetbrains.kotlin.utils.PathUtil
 import java.io.File
 
 interface JvmContentRootBase : ContentRoot
@@ -82,3 +87,25 @@ val CompilerConfiguration.javaSourceRoots: Set<String>
             else -> null
         }
     }
+
+fun CompilerConfiguration.configureJdkClasspathRoots() {
+    if (getBoolean(JVMConfigurationKeys.NO_JDK)) return
+
+    val jdkHome = get(JVMConfigurationKeys.JDK_HOME)
+    val (javaRoot, classesRoots) = if (jdkHome == null) {
+        val javaHome = File(System.getProperty("java.home"))
+        put(JVMConfigurationKeys.JDK_HOME, javaHome)
+
+        javaHome to PathUtil.getJdkClassesRootsFromCurrentJre()
+    } else {
+        jdkHome to PathUtil.getJdkClassesRoots(jdkHome)
+    }
+
+    if (!CoreJrtFileSystem.isModularJdk(javaRoot)) {
+        if (classesRoots.isEmpty()) {
+            report(CompilerMessageSeverity.ERROR, "No class roots are found in the JDK path: $javaRoot")
+        } else {
+            addJvmSdkRoots(classesRoots)
+        }
+    }
+}

compiler/daemon/src/org/jetbrains/kotlin/daemon/KotlinRemoteReplService.kt

@@ -22,6 +22,7 @@ import org.jetbrains.kotlin.cli.common.extensions.ReplFactoryExtension
 import org.jetbrains.kotlin.cli.common.messages.*
 import org.jetbrains.kotlin.cli.common.repl.*
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
+import org.jetbrains.kotlin.cli.jvm.config.configureJdkClasspathRoots
 import org.jetbrains.kotlin.cli.jvm.config.addJvmClasspathRoots
 import org.jetbrains.kotlin.cli.jvm.plugins.ServiceLoaderLite
 import org.jetbrains.kotlin.compiler.plugin.ComponentRegistrar
@@ -54,6 +55,7 @@ abstract class KotlinJvmReplServiceBase(
         put(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, messageCollector)
         addJvmClasspathRoots(PathUtil.kotlinPathsForCompiler.let { listOf(it.stdlibPath, it.reflectPath, it.scriptRuntimePath) })
         addJvmClasspathRoots(templateClasspath)
+        configureJdkClasspathRoots()
         put(CommonConfigurationKeys.MODULE_NAME, "kotlin-script")
         languageVersionSettings = LanguageVersionSettingsImpl(
                 LanguageVersion.LATEST_STABLE, ApiVersion.LATEST_STABLE, mapOf(AnalysisFlags.skipMetadataVersionCheck to true)

compiler/fir/modularized-tests/tests/org/jetbrains/kotlin/fir/AbstractModularizedTest.kt

@@ -8,6 +8,7 @@ package org.jetbrains.kotlin.fir
 import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
 import org.jetbrains.kotlin.cli.common.config.KotlinSourceRoot
 import org.jetbrains.kotlin.cli.common.setupLanguageVersionSettings
+import org.jetbrains.kotlin.cli.jvm.config.configureJdkClasspathRoots
 import org.jetbrains.kotlin.cli.jvm.config.addJavaSourceRoot
 import org.jetbrains.kotlin.cli.jvm.config.addJvmClasspathRoots
 import org.jetbrains.kotlin.config.*
@@ -105,6 +106,7 @@ abstract class AbstractModularizedTest : KtUsefulTestCase() {
             ApiVersion.LATEST_STABLE,
             analysisFlags = mutableMapOf(AnalysisFlags.optIn to moduleData.optInAnnotations)
         )
+        configuration.configureJdkClasspathRoots()
 
         // in case of modular jdk only
         configuration.putIfNotNull(JVMConfigurationKeys.JDK_HOME, moduleData.modularJdkRoot)

compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalFirJvmCompilerRunner.kt

@@ -28,15 +28,9 @@ import org.jetbrains.kotlin.cli.common.messages.MessageCollector
 import org.jetbrains.kotlin.cli.common.modules.ModuleBuilder
 import org.jetbrains.kotlin.cli.common.setupCommonArguments
 import org.jetbrains.kotlin.cli.jvm.*
-import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
+import org.jetbrains.kotlin.cli.jvm.compiler.*
-import org.jetbrains.kotlin.cli.jvm.compiler.VfsBasedProjectEnvironment
-import org.jetbrains.kotlin.cli.jvm.compiler.findMainClass
-import org.jetbrains.kotlin.cli.jvm.compiler.forAllFiles
 import org.jetbrains.kotlin.cli.jvm.compiler.pipeline.*
-import org.jetbrains.kotlin.cli.jvm.config.ClassicFrontendSpecificJvmConfigurationKeys
+import org.jetbrains.kotlin.cli.jvm.config.*
-import org.jetbrains.kotlin.cli.jvm.config.JvmClasspathRoot
-import org.jetbrains.kotlin.cli.jvm.config.JvmModulePathRoot
-import org.jetbrains.kotlin.cli.jvm.config.addJavaSourceRoot
 import org.jetbrains.kotlin.cli.jvm.plugins.PluginCliParser
 import org.jetbrains.kotlin.config.*
 import org.jetbrains.kotlin.diagnostics.DiagnosticReporterFactory
@@ -156,6 +150,7 @@ class IncrementalFirJvmCompilerRunner(
                 configureStandardLibs(paths, args)
                 configureAdvancedJvmOptions(args)
                 configureKlibPaths(args)
+                configureJdkClasspathRoots()
 
                 val destination = File(args.destination ?: ".")
                 if (destination.path.endsWith(".jar")) {

compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalJvmCompilerRunner.kt

@@ -39,6 +39,7 @@ import org.jetbrains.kotlin.cli.common.messages.MessageCollector
 import org.jetbrains.kotlin.cli.jvm.K2JVMCompiler
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
+import org.jetbrains.kotlin.cli.jvm.config.configureJdkClasspathRoots
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.IncrementalCompilation
 import org.jetbrains.kotlin.config.Services
@@ -167,6 +168,7 @@ open class IncrementalJvmCompilerRunner(
             val configuration = CompilerConfiguration()
             val filterMessageCollector = FilteringMessageCollector(messageCollector, { !it.isError })
             configuration.put(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, filterMessageCollector)
+            configuration.configureJdkClasspathRoots()
             val environment = KotlinCoreEnvironment.createForProduction(rootDisposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES)
             val project = environment.project
             PsiFileFactory.getInstance(project)

compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/parsing/parseFileUtils.kt

@@ -16,6 +16,7 @@ import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
+import org.jetbrains.kotlin.cli.jvm.config.configureJdkClasspathRoots
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.JVMConfigurationKeys
 import org.jetbrains.kotlin.psi.KtClassOrObject
@@ -42,6 +43,7 @@ private fun classesFqNames(kotlinFiles: Collection<File>, disposable: Disposable
     val config = CompilerConfiguration()
     config.put(JVMConfigurationKeys.NO_JDK, true)
     config.put(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, MessageCollector.NONE)
+    config.configureJdkClasspathRoots()
     val configFiles = EnvironmentConfigFiles.JVM_CONFIG_FILES
     val environment = KotlinCoreEnvironment.createForProduction(disposable, config, configFiles)
     val psiManager = PsiManager.getInstance(environment.project)

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/configuration/JvmEnvironmentConfigurator.kt

@@ -262,6 +262,7 @@ class JvmEnvironmentConfigurator(testServices: TestServices) : EnvironmentConfig
 
         configuration.put(JVMConfigurationKeys.VALIDATE_IR, true)
         configuration.put(JVMConfigurationKeys.VALIDATE_BYTECODE, true)
+        configuration.configureJdkClasspathRoots()
     }
 
     private fun addJavaSourceRootsByJavaModules(configuration: CompilerConfiguration, moduleInfoFiles: List<TestFile>) {

compiler/tests-common/tests/org/jetbrains/kotlin/test/KotlinTestUtils.java

@@ -60,7 +60,6 @@ import java.lang.annotation.Annotation;
 import java.lang.reflect.Method;
 import java.nio.file.Path;
 import java.util.*;
-import java.util.function.Function;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
@@ -212,6 +211,7 @@ public class KotlinTestUtils {
         }
 
         JvmContentRootsKt.addJvmClasspathRoots(configuration, classpath);
+        JvmContentRootsKt.configureJdkClasspathRoots(configuration);
 
         return configuration;
     }

libraries/tools/kotlin-maven-plugin/src/main/java/org/jetbrains/kotlin/maven/ExecuteKotlinScriptMojo.java

@@ -41,6 +41,7 @@ import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinToJVMBytecodeCompiler;
 import org.jetbrains.kotlin.cli.jvm.config.JvmClasspathRoot;
+import org.jetbrains.kotlin.cli.jvm.config.JvmContentRootsKt;
 import org.jetbrains.kotlin.codegen.GeneratedClassLoader;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
 import org.jetbrains.kotlin.compiler.plugin.ComponentRegistrar;
@@ -193,6 +194,7 @@ public class ExecuteKotlinScriptMojo extends AbstractMojo {
                     JvmScriptingHostConfigurationKt.getDefaultJvmScriptingHostConfiguration()
             );
 
+            JvmContentRootsKt.configureJdkClasspathRoots(configuration);
             KotlinCoreEnvironment environment = KotlinCoreEnvironment.createForProduction(rootDisposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES);
 
             GenerationState state = KotlinToJVMBytecodeCompiler.INSTANCE.analyzeAndGenerate(environment);

libraries/tools/kotlin-script-util/src/main/kotlin/org/jetbrains/kotlin/script/jsr223/KotlinJsr223JvmLocalScriptEngine.kt

@@ -19,6 +19,7 @@ package org.jetbrains.kotlin.script.jsr223
 import org.jetbrains.kotlin.cli.common.messages.MessageRenderer
 import org.jetbrains.kotlin.cli.common.messages.PrintingMessageCollector
 import org.jetbrains.kotlin.cli.common.repl.*
+import org.jetbrains.kotlin.cli.jvm.config.configureJdkClasspathRoots
 import org.jetbrains.kotlin.cli.jvm.config.addJvmClasspathRoots
 import org.jetbrains.kotlin.cli.jvm.config.addJvmSdkRoots
 import org.jetbrains.kotlin.compiler.plugin.ComponentRegistrar
@@ -69,6 +70,7 @@ class KotlinJsr223JvmLocalScriptEngine(
     private fun makeCompilerConfiguration() = CompilerConfiguration().apply {
         addJvmSdkRoots(PathUtil.getJdkClassesRootsFromCurrentJre())
         addJvmClasspathRoots(templateClasspath)
+        configureJdkClasspathRoots()
         add(ComponentRegistrar.PLUGIN_COMPONENT_REGISTRARS, ScriptingCompilerConfigurationComponentRegistrar())
         put(CommonConfigurationKeys.MODULE_NAME, "kotlin-script")
         languageVersionSettings = LanguageVersionSettingsImpl(

libraries/tools/kotlin-script-util/src/test/kotlin/org/jetbrains/kotlin/script/util/ScriptUtilIT.kt

@@ -22,6 +22,7 @@ import org.jetbrains.kotlin.cli.common.config.addKotlinSourceRoot
 import org.jetbrains.kotlin.cli.common.messages.*
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
+import org.jetbrains.kotlin.cli.jvm.config.configureJdkClasspathRoots
 import org.jetbrains.kotlin.cli.jvm.config.addJvmClasspathRoot
 import org.jetbrains.kotlin.cli.jvm.config.addJvmClasspathRoots
 import org.jetbrains.kotlin.cli.jvm.config.jvmClasspathRoots
@@ -125,6 +126,7 @@ done
         try {
             val configuration = CompilerConfiguration().apply {
                 addJvmClasspathRoots(scriptCompilationClasspathFromContext(KOTLIN_JAVA_RUNTIME_JAR))
+                configureJdkClasspathRoots()
 
                 put(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, messageCollector)
                 addKotlinSourceRoot(scriptPath)

plugins/scripting/scripting-compiler/src/org/jetbrains/kotlin/scripting/compiler/plugin/impl/compilationContext.kt

@@ -17,6 +17,7 @@ import org.jetbrains.kotlin.cli.common.setupCommonArguments
 import org.jetbrains.kotlin.cli.jvm.*
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
+import org.jetbrains.kotlin.cli.jvm.config.configureJdkClasspathRoots
 import org.jetbrains.kotlin.cli.jvm.config.JvmClasspathRoot
 import org.jetbrains.kotlin.cli.jvm.config.addJvmClasspathRoots
 import org.jetbrains.kotlin.cli.jvm.config.jvmClasspathRoots
@@ -284,6 +285,7 @@ private fun createInitialCompilerConfiguration(
         put(CommonConfigurationKeys.MODULE_NAME, baseArguments.moduleName ?: "kotlin-script")
 
         configureAdvancedJvmOptions(baseArguments)
+        configureJdkClasspathRoots()
     }
 }