Minor refactoring in ContentRoots, JvmContentRoots and usages

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

@@ -30,9 +30,9 @@ import org.jetbrains.kotlin.cli.jvm.compiler.CompileEnvironmentUtil
 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.addJavaSourceRoot
 import org.jetbrains.kotlin.cli.jvm.config.addJvmClasspathRoots
+import org.jetbrains.kotlin.cli.jvm.config.jvmClasspathRoots
 import org.jetbrains.kotlin.cli.jvm.repl.ReplFromTerminal
 import org.jetbrains.kotlin.codegen.CompilationException
 import org.jetbrains.kotlin.compiler.plugin.CliOptionProcessingException
@@ -412,7 +412,7 @@ class K2JVMCompiler : CLICompiler<K2JVMCompilerArguments>() {
                                        configuration: CompilerConfiguration,
                                        messageCollector: MessageCollector,
                                        scriptResolverEnv: HashMap<String, Any?>) {
-            val classpath = configuration.getList(JVMConfigurationKeys.CONTENT_ROOTS).filterIsInstance(JvmClasspathRoot::class.java).mapNotNull { it.file }
+            val classpath = configuration.jvmClasspathRoots
             // TODO: consider using escaping to allow kotlin escaped names in class names
             if (scriptTemplates != null && scriptTemplates.isNotEmpty()) {
                 val classloader = URLClassLoader(classpath.map { it.toURI().toURL() }.toTypedArray(), Thread.currentThread().contextClassLoader)

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

@@ -22,35 +22,40 @@ import org.jetbrains.kotlin.config.JVMConfigurationKeys
 import org.jetbrains.kotlin.config.KotlinSourceRoot
 import java.io.File
 
-data class JvmClasspathRoot(override val file: File): JvmContentRoot
-
-data class JavaSourceRoot(override val file: File, val packagePrefix: String?): JvmContentRoot
-
 interface JvmContentRoot : ContentRoot {
     val file: File
 }
 
+data class JvmClasspathRoot(override val file: File) : JvmContentRoot
+
+data class JavaSourceRoot(override val file: File, val packagePrefix: String?) : JvmContentRoot
+
 fun CompilerConfiguration.addJvmClasspathRoot(file: File) {
     add(JVMConfigurationKeys.CONTENT_ROOTS, JvmClasspathRoot(file))
 }
 
-fun CompilerConfiguration.addJvmClasspathRoots(files: List<File>): Unit = files.forEach { addJvmClasspathRoot(it) }
+fun CompilerConfiguration.addJvmClasspathRoots(files: List<File>) {
+    files.forEach(this::addJvmClasspathRoot)
+}
 
 val CompilerConfiguration.jvmClasspathRoots: List<File>
-    get() {
-        return get(JVMConfigurationKeys.CONTENT_ROOTS)?.filterIsInstance<JvmClasspathRoot>()?.map { it.file } ?: emptyList()
-    }
+    get() = getList(JVMConfigurationKeys.CONTENT_ROOTS).filterIsInstance<JvmClasspathRoot>().map(JvmContentRoot::file)
 
-@JvmOverloads fun CompilerConfiguration.addJavaSourceRoot(file: File, packagePrefix: String? = null) {
+@JvmOverloads
+fun CompilerConfiguration.addJavaSourceRoot(file: File, packagePrefix: String? = null) {
     add(JVMConfigurationKeys.CONTENT_ROOTS, JavaSourceRoot(file, packagePrefix))
 }
 
-@JvmOverloads fun CompilerConfiguration.addJavaSourceRoots(files: List<File>, packagePrefix: String? = null): Unit =
-        files.forEach { addJavaSourceRoot(it, packagePrefix) }
+@JvmOverloads
+fun CompilerConfiguration.addJavaSourceRoots(files: List<File>, packagePrefix: String? = null) {
+    files.forEach { addJavaSourceRoot(it, packagePrefix) }
+}
 
 val CompilerConfiguration.javaSourceRoots: Set<String>
-    get() = get(JVMConfigurationKeys.CONTENT_ROOTS)
-            ?.mapNotNullTo(hashSetOf<String>()) {
-                (it as? KotlinSourceRoot)?.path ?: (it as? JavaSourceRoot)?.file?.path
+    get() = getList(JVMConfigurationKeys.CONTENT_ROOTS).mapNotNullTo(linkedSetOf<String>()) { root ->
+                when (root) {
+                    is KotlinSourceRoot -> root.path
+                    is JavaSourceRoot -> root.file.path
+                    else -> null
+                }
             }
-            .orEmpty()

compiler/frontend.java/src/org/jetbrains/kotlin/config/ContentRoots.kt

@@ -25,7 +25,7 @@ fun CompilerConfiguration.addKotlinSourceRoot(source: String) {
 }
 
 fun CompilerConfiguration.addKotlinSourceRoots(sources: List<String>): Unit =
-        sources.forEach { addKotlinSourceRoot(it) }
+        sources.forEach(this::addKotlinSourceRoot)
 
 val CompilerConfiguration.kotlinSourceRoots: List<String>
     get() = get(JVMConfigurationKeys.CONTENT_ROOTS)?.filterIsInstance<KotlinSourceRoot>()?.map { it.path }.orEmpty()

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

@@ -57,7 +57,10 @@ import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.cli.jvm.config.JvmContentRootsKt;
 import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime;
-import org.jetbrains.kotlin.config.*;
+import org.jetbrains.kotlin.config.CommonConfigurationKeys;
+import org.jetbrains.kotlin.config.CompilerConfiguration;
+import org.jetbrains.kotlin.config.ContentRootsKt;
+import org.jetbrains.kotlin.config.JVMConfigurationKeys;
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.kotlin.diagnostics.Diagnostic;
 import org.jetbrains.kotlin.diagnostics.Errors;
@@ -542,13 +545,10 @@ public class KotlinTestUtils {
     }
 
     public static void resolveAllKotlinFiles(KotlinCoreEnvironment environment) throws IOException {
-        List<ContentRoot> paths = environment.getConfiguration().get(JVMConfigurationKeys.CONTENT_ROOTS);
-        if (paths == null) return;
+        List<String> paths = ContentRootsKt.getKotlinSourceRoots(environment.getConfiguration());
+        if (paths.isEmpty()) return;
         List<KtFile> ktFiles = new ArrayList<>();
-        for (ContentRoot root : paths) {
-            if (!(root instanceof KotlinSourceRoot)) continue;
-
-            String path = ((KotlinSourceRoot) root).getPath();
+        for (String path : paths) {
             File file = new File(path);
             if (file.isFile()) {
                 ktFiles.add(loadJetFile(environment.getProject(), file));