Make JDK classpath roots configuration explicit...

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

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)
+        }
+    }
+}