Refactor CompilerConfiguration: keys -> Content roots

Represent classpath roots and java source roots as separate entities

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

@@ -24,11 +24,11 @@ import org.jetbrains.kotlin.analyzer.ModuleInfo
 import org.jetbrains.kotlin.builtins.BuiltInsSerializationUtil
 import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector
-import org.jetbrains.kotlin.cli.jvm.JVMConfigurationKeys
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
-import org.jetbrains.kotlin.config.CommonConfigurationKeys
+import org.jetbrains.kotlin.cli.jvm.config.addJvmClasspathRoots
 import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.config.addKotlinSourceRoots
 import org.jetbrains.kotlin.context.GlobalContext
 import org.jetbrains.kotlin.descriptors.ClassDescriptor
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor
@@ -52,8 +52,8 @@ public class BuiltInsSerializer(private val dependOnOldBuiltIns: Boolean) {
 
     public fun serialize(
             destDir: File,
-            srcDirs: Collection<File>,
-            extraClassPath: Collection<File>,
+            srcDirs: List<File>,
+            extraClassPath: List<File>,
             onComplete: (totalSize: Int, totalFiles: Int) -> Unit
     ) {
         val rootDisposable = Disposer.newDisposable()
@@ -73,16 +73,12 @@ public class BuiltInsSerializer(private val dependOnOldBuiltIns: Boolean) {
                 if (dependOnOldBuiltIns) ModuleInfo.DependenciesOnBuiltins.LAST else ModuleInfo.DependenciesOnBuiltins.NONE
     }
 
-    private fun serialize(disposable: Disposable, destDir: File, srcDirs: Collection<File>, extraClassPath: Collection<File>) {
+    private fun serialize(disposable: Disposable, destDir: File, srcDirs: List<File>, extraClassPath: List<File>) {
         val configuration = CompilerConfiguration()
         configuration.put(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, MessageCollector.NONE)
 
-        val sourceRoots = srcDirs map { it.path }
-        configuration.put(CommonConfigurationKeys.SOURCE_ROOTS_KEY, sourceRoots)
-
-        for (path in extraClassPath) {
-            configuration.add(JVMConfigurationKeys.CLASSPATH_KEY, path)
-        }
+        configuration.addKotlinSourceRoots(srcDirs.map { it.path })
+        configuration.addJvmClasspathRoots(extraClassPath)
 
         val environment = KotlinCoreEnvironment.createForTests(disposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES)
 

compiler/cli/src/org/jetbrains/kotlin/cli/js/K2JSCompiler.java

@@ -29,7 +29,6 @@ import kotlin.Function1;
 import kotlin.Unit;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.kotlin.utils.serializer.KotlinJavaScriptSerializer;
 import org.jetbrains.kotlin.analyzer.AnalysisResult;
 import org.jetbrains.kotlin.backend.common.output.OutputFileCollection;
 import org.jetbrains.kotlin.cli.common.CLICompiler;
@@ -42,11 +41,10 @@ import org.jetbrains.kotlin.cli.common.messages.CompilerMessageLocation;
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity;
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector;
 import org.jetbrains.kotlin.cli.common.output.outputUtils.OutputUtilsPackage;
-import org.jetbrains.kotlin.cli.jvm.JVMConfigurationKeys;
 import org.jetbrains.kotlin.cli.jvm.compiler.CompilerJarLocator;
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
-import org.jetbrains.kotlin.config.CommonConfigurationKeys;
+import org.jetbrains.kotlin.cli.jvm.config.JVMConfigurationKeys;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
 import org.jetbrains.kotlin.config.Services;
 import org.jetbrains.kotlin.js.analyze.TopDownAnalyzerFacadeForJS;
@@ -59,6 +57,7 @@ import org.jetbrains.kotlin.js.facade.MainCallParameters;
 import org.jetbrains.kotlin.js.facade.TranslationResult;
 import org.jetbrains.kotlin.psi.JetFile;
 import org.jetbrains.kotlin.utils.PathUtil;
+import org.jetbrains.kotlin.utils.serializer.KotlinJavaScriptSerializer;
 
 import java.io.File;
 import java.util.List;
@@ -66,6 +65,7 @@ import java.util.List;
 import static org.jetbrains.kotlin.cli.common.ExitCode.COMPILATION_ERROR;
 import static org.jetbrains.kotlin.cli.common.ExitCode.OK;
 import static org.jetbrains.kotlin.cli.common.messages.CompilerMessageLocation.NO_LOCATION;
+import static org.jetbrains.kotlin.config.ConfigPackage.addKotlinSourceRoots;
 
 public class K2JSCompiler extends CLICompiler<K2JSCompilerArguments> {
 
@@ -101,7 +101,7 @@ public class K2JSCompiler extends CLICompiler<K2JSCompilerArguments> {
             configuration.put(JVMConfigurationKeys.COMPILER_JAR_LOCATOR, locator);
         }
 
-        configuration.addAll(CommonConfigurationKeys.SOURCE_ROOTS_KEY, arguments.freeArgs);
+        addKotlinSourceRoots(configuration, arguments.freeArgs);
         KotlinCoreEnvironment environmentForJS =
                 KotlinCoreEnvironment.createForProduction(rootDisposable, configuration, EnvironmentConfigFiles.JS_CONFIG_FILES);
 

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

@@ -27,10 +27,12 @@ import org.jetbrains.kotlin.cli.common.arguments.K2JVMCompilerArguments;
 import org.jetbrains.kotlin.cli.common.messages.*;
 import org.jetbrains.kotlin.cli.common.modules.ModuleScriptData;
 import org.jetbrains.kotlin.cli.jvm.compiler.*;
+import org.jetbrains.kotlin.cli.jvm.config.JVMConfigurationKeys;
 import org.jetbrains.kotlin.cli.jvm.repl.ReplFromTerminal;
 import org.jetbrains.kotlin.codegen.CompilationException;
-import org.jetbrains.kotlin.compiler.plugin.*;
-import org.jetbrains.kotlin.config.CommonConfigurationKeys;
+import org.jetbrains.kotlin.compiler.plugin.CliOptionProcessingException;
+import org.jetbrains.kotlin.compiler.plugin.PluginCliOptionProcessingException;
+import org.jetbrains.kotlin.compiler.plugin.PluginPackage;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
 import org.jetbrains.kotlin.config.Services;
 import org.jetbrains.kotlin.load.kotlin.incremental.cache.IncrementalCacheProvider;
@@ -45,6 +47,8 @@ import java.util.List;
 
 import static com.google.common.base.Predicates.in;
 import static org.jetbrains.kotlin.cli.common.ExitCode.*;
+import static org.jetbrains.kotlin.cli.jvm.config.ConfigPackage.*;
+import static org.jetbrains.kotlin.config.ConfigPackage.addKotlinSourceRoot;
 
 @SuppressWarnings("UseOfSystemOutOrSystemErr")
 public class K2JVMCompiler extends CLICompiler<K2JVMCompilerArguments> {
@@ -83,7 +87,7 @@ public class K2JVMCompiler extends CLICompiler<K2JVMCompilerArguments> {
 
         try {
             if (!arguments.noJdk) {
-                configuration.addAll(JVMConfigurationKeys.CLASSPATH_KEY, PathUtil.getJdkClassesRoots());
+                addJvmClasspathRoots(configuration, PathUtil.getJdkClassesRoots());
             }
         }
         catch (Throwable t) {
@@ -114,21 +118,20 @@ public class K2JVMCompiler extends CLICompiler<K2JVMCompilerArguments> {
                                         CompilerMessageLocation.NO_LOCATION);
                 return COMPILATION_ERROR;
             }
-            configuration.add(CommonConfigurationKeys.SOURCE_ROOTS_KEY, arguments.freeArgs.get(0));
+            addKotlinSourceRoot(configuration, arguments.freeArgs.get(0));
         }
         else if (arguments.module == null) {
-            configuration.addAll(CommonConfigurationKeys.SOURCE_ROOTS_KEY, arguments.freeArgs);
-
-            // Adding all directory sources to classpath to resolve Java symbols from Kotlin
-            for (String source : arguments.freeArgs) {
-                File file = new File(source);
+            for (String arg : arguments.freeArgs) {
+                addKotlinSourceRoot(configuration, arg);
+                File file = new File(arg);
                 if (file.isDirectory()) {
-                    configuration.add(JVMConfigurationKeys.CLASSPATH_KEY, file);
+                    addJavaSourceRoot(configuration, file);
                 }
             }
         }
 
-        configuration.addAll(JVMConfigurationKeys.CLASSPATH_KEY, getClasspath(paths, arguments));
+        addJvmClasspathRoots(configuration, getClasspath(paths, arguments));
+
         configuration.addAll(JVMConfigurationKeys.ANNOTATIONS_PATH_KEY, getAnnotationsPath(paths, arguments));
 
         if (arguments.module == null && arguments.freeArgs.isEmpty() && !arguments.version) {

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/CompileEnvironmentUtil.java

@@ -42,11 +42,10 @@ import org.jetbrains.kotlin.cli.common.messages.MessageCollector;
 import org.jetbrains.kotlin.cli.common.messages.OutputMessageUtil;
 import org.jetbrains.kotlin.cli.common.modules.ModuleScriptData;
 import org.jetbrains.kotlin.cli.common.modules.ModuleXmlParser;
-import org.jetbrains.kotlin.cli.jvm.JVMConfigurationKeys;
+import org.jetbrains.kotlin.cli.jvm.config.JVMConfigurationKeys;
 import org.jetbrains.kotlin.codegen.ClassFileFactory;
 import org.jetbrains.kotlin.codegen.GeneratedClassLoader;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
-import org.jetbrains.kotlin.config.CommonConfigurationKeys;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
 import org.jetbrains.kotlin.idea.JetFileType;
 import org.jetbrains.kotlin.load.kotlin.PackageClassUtils;
@@ -69,6 +68,9 @@ import java.util.jar.*;
 
 import static org.jetbrains.kotlin.cli.common.messages.CompilerMessageLocation.NO_LOCATION;
 import static org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity.ERROR;
+import static org.jetbrains.kotlin.cli.jvm.config.ConfigPackage.addJvmClasspathRoot;
+import static org.jetbrains.kotlin.cli.jvm.config.ConfigPackage.addJvmClasspathRoots;
+import static org.jetbrains.kotlin.config.ConfigPackage.addKotlinSourceRoot;
 
 public class CompileEnvironmentUtil {
 
@@ -95,14 +97,15 @@ public class CompileEnvironmentUtil {
         CompilerConfiguration configuration = new CompilerConfiguration();
         File runtimePath = paths.getRuntimePath();
         if (runtimePath.exists()) {
-            configuration.add(JVMConfigurationKeys.CLASSPATH_KEY, runtimePath);
+            addJvmClasspathRoot(configuration, runtimePath);
         }
-        configuration.addAll(JVMConfigurationKeys.CLASSPATH_KEY, PathUtil.getJdkClassesRoots());
+        addJvmClasspathRoots(configuration, PathUtil.getJdkClassesRoots());
+
         File jdkAnnotationsPath = paths.getJdkAnnotationsPath();
         if (jdkAnnotationsPath.exists()) {
             configuration.add(JVMConfigurationKeys.ANNOTATIONS_PATH_KEY, jdkAnnotationsPath);
         }
-        configuration.add(CommonConfigurationKeys.SOURCE_ROOTS_KEY, moduleScriptFile);
+        addKotlinSourceRoot(configuration, moduleScriptFile);
         configuration.put(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, messageCollector);
 
         List<Module> modules;

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

@@ -37,6 +37,7 @@ import com.intellij.openapi.fileTypes.PlainTextFileType
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.util.Disposer
 import com.intellij.openapi.util.io.FileUtil
+import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.psi.FileContextProvider
 import com.intellij.psi.PsiElementFinder
 import com.intellij.psi.PsiManager
@@ -58,11 +59,13 @@ import org.jetbrains.kotlin.cli.common.messages.CompilerMessageLocation
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity.ERROR
 import org.jetbrains.kotlin.cli.common.messages.CompilerMessageSeverity.WARNING
-import org.jetbrains.kotlin.cli.jvm.JVMConfigurationKeys
+import org.jetbrains.kotlin.cli.jvm.config.*
 import org.jetbrains.kotlin.codegen.extensions.ExpressionCodegenExtension
 import org.jetbrains.kotlin.compiler.plugin.ComponentRegistrar
 import org.jetbrains.kotlin.config.CommonConfigurationKeys
 import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.config.ContentRoot
+import org.jetbrains.kotlin.config.KotlinSourceRoot
 import org.jetbrains.kotlin.extensions.ExternalDeclarationsProvider
 import org.jetbrains.kotlin.idea.JetFileType
 import org.jetbrains.kotlin.load.kotlin.KotlinBinaryClassCache
@@ -110,9 +113,8 @@ public class KotlinCoreEnvironment private(
         registerProjectServicesForCLI(projectEnvironment)
         registerProjectServices(projectEnvironment)
 
-        for (path in configuration.getList(JVMConfigurationKeys.CLASSPATH_KEY)) {
-            addToClasspath(path)
-        }
+        fillClasspath(configuration)
+
         for (path in configuration.getList(JVMConfigurationKeys.ANNOTATIONS_PATH_KEY)) {
             addExternalAnnotationsRoot(path)
         }
@@ -155,33 +157,55 @@ public class KotlinCoreEnvironment private(
         annotationsManager.addExternalAnnotationsRoot(PathUtil.jarFileOrDirectoryToVirtualFile(path))
     }
 
-    private fun addToClasspath(path: File) {
-        if (path.isFile()) {
-            val jarFile = applicationEnvironment.getJarFileSystem().findFileByPath("${path}!/")
-            if (jarFile == null) {
-                report(WARNING, "Classpath entry points to a file that is not a JAR archive: $path")
-                return
-            }
-            projectEnvironment.addJarToClassPath(path)
-            classPath.add(jarFile)
+    private fun fillClasspath(configuration: CompilerConfiguration) {
+        for (root in configuration.getList(CommonConfigurationKeys.CONTENT_ROOTS)) {
+            val javaRoot = root as? JvmContentRoot ?: continue
+            val virtualFile = contentRootToVirtualFile(javaRoot) ?: continue
+
+            projectEnvironment.addSourcesToClasspath(virtualFile)
+            classPath.add(virtualFile)
         }
-        else {
-            val root = applicationEnvironment.getLocalFileSystem().findFileByPath(path.getAbsolutePath())
-            if (root == null) {
-                report(WARNING, "Classpath entry points to a non-existent location: $path")
-                return
+    }
+
+    private fun contentRootToVirtualFile(root: JvmContentRoot): VirtualFile? {
+        when (root) {
+            is JvmClasspathRoot -> {
+                return if (root.file.isFile()) findJarRoot(root) else findLocalDirectory(root)
             }
-            projectEnvironment.addSourcesToClasspath(root)
-            classPath.add(root)
+            is JavaSourceRoot -> {
+                return if (root.file.isDirectory()) findLocalDirectory(root) else null
+            }
+            else -> throw IllegalStateException("Unexpected root: $root")
         }
     }
 
+    private fun findLocalDirectory(root: JvmContentRoot): VirtualFile? {
+        val path = root.file
+        val localFile = applicationEnvironment.getLocalFileSystem().findFileByPath(path.getAbsolutePath())
+        if (localFile == null) {
+            report(WARNING, "Classpath entry points to a non-existent location: $path")
+            return null
+        }
+        return localFile
+    }
+
+    private fun findJarRoot(root: JvmClasspathRoot): VirtualFile? {
+        val path = root.file
+        val jarFile = applicationEnvironment.getJarFileSystem().findFileByPath("${path}!/")
+        if (jarFile == null) {
+            report(WARNING, "Classpath entry points to a file that is not a JAR archive: $path")
+            return null
+        }
+        return jarFile
+    }
+
     private fun getSourceRootsCheckingForDuplicates(): Collection<String> {
         val uniqueSourceRoots = Sets.newLinkedHashSet<String>()
 
-        for (sourceRoot in configuration.getList(CommonConfigurationKeys.SOURCE_ROOTS_KEY)) {
-            if (!uniqueSourceRoots.add(sourceRoot)) {
-                report(WARNING, "Duplicate source root: " + sourceRoot)
+        configuration.getList(CommonConfigurationKeys.CONTENT_ROOTS).filterIsInstance<KotlinSourceRoot>().forEach { sourceRoot ->
+            val path = sourceRoot.path
+            if (!uniqueSourceRoots.add(path)) {
+                report(WARNING, "Duplicate source root: $path")
             }
         }
 

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java

@@ -36,11 +36,10 @@ import org.jetbrains.kotlin.cli.common.CompilerPluginContext;
 import org.jetbrains.kotlin.cli.common.messages.AnalyzerWithCompilerReport;
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector;
 import org.jetbrains.kotlin.cli.common.output.outputUtils.OutputUtilsPackage;
-import org.jetbrains.kotlin.cli.jvm.JVMConfigurationKeys;
+import org.jetbrains.kotlin.cli.jvm.config.JVMConfigurationKeys;
 import org.jetbrains.kotlin.codegen.*;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
 import org.jetbrains.kotlin.codegen.state.Progress;
-import org.jetbrains.kotlin.config.CommonConfigurationKeys;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
 import org.jetbrains.kotlin.context.ContextPackage;
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
@@ -63,7 +62,14 @@ import org.jetbrains.kotlin.utils.KotlinPaths;
 import java.io.File;
 import java.net.URL;
 import java.net.URLClassLoader;
-import java.util.*;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+
+import static org.jetbrains.kotlin.cli.jvm.config.ConfigPackage.addJvmClasspathRoot;
+import static org.jetbrains.kotlin.cli.jvm.config.ConfigPackage.getJvmClasspathRoots;
+import static org.jetbrains.kotlin.config.ConfigPackage.addKotlinSourceRoots;
 
 public class KotlinToJVMBytecodeCompiler {
 
@@ -165,10 +171,10 @@ public class KotlinToJVMBytecodeCompiler {
         CompilerConfiguration configuration = base.copy();
 
         for (Module module : chunk) {
-            configuration.addAll(CommonConfigurationKeys.SOURCE_ROOTS_KEY, getAbsolutePaths(directory, module));
+            addKotlinSourceRoots(configuration, getAbsolutePaths(directory, module));
 
             for (String classpathRoot : module.getClasspathRoots()) {
-                configuration.add(JVMConfigurationKeys.CLASSPATH_KEY, new File(classpathRoot));
+                addJvmClasspathRoot(configuration, new File(classpathRoot));
             }
 
             for (String annotationsRoot : module.getAnnotationsRoots()) {
@@ -261,7 +267,7 @@ public class KotlinToJVMBytecodeCompiler {
         GeneratedClassLoader classLoader;
         try {
             List<URL> classPaths = Lists.newArrayList(paths.getRuntimePath().toURI().toURL());
-            for (File file : configuration.get(JVMConfigurationKeys.CLASSPATH_KEY, Collections.<File>emptyList())) {
+            for (File file : getJvmClasspathRoots(configuration)) {
                 classPaths.add(file.toURI().toURL());
             }
             classLoader = new GeneratedClassLoader(state.getFactory(),

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/config/JVMConfigurationKeys.java

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 
-package org.jetbrains.kotlin.cli.jvm;
+package org.jetbrains.kotlin.cli.jvm.config;
 
 import org.jetbrains.kotlin.cli.jvm.compiler.CompilerJarLocator;
 import org.jetbrains.kotlin.config.CompilerConfigurationKey;
@@ -28,7 +28,6 @@ public class JVMConfigurationKeys {
     private JVMConfigurationKeys() {
     }
 
-    public static final CompilerConfigurationKey<List<File>> CLASSPATH_KEY = CompilerConfigurationKey.create("classpath");
     public static final CompilerConfigurationKey<List<File>> ANNOTATIONS_PATH_KEY = CompilerConfigurationKey.create("annotations path");
 
     public static final CompilerConfigurationKey<List<AnalyzerScriptParameter>> SCRIPT_PARAMETERS =

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

@@ -0,0 +1,47 @@
+/*
+ * Copyright 2010-2015 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.cli.jvm.config
+
+import org.jetbrains.kotlin.config.CommonConfigurationKeys
+import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.config.ContentRoot
+import java.io.File
+
+public data class JvmClasspathRoot(public override val file: File): JvmContentRoot
+
+public data class JavaSourceRoot(public override val file: File): JvmContentRoot
+
+public trait JvmContentRoot : ContentRoot {
+    public val file: File
+}
+
+public fun CompilerConfiguration.addJvmClasspathRoot(file: File) {
+    add(CommonConfigurationKeys.CONTENT_ROOTS, JvmClasspathRoot(file))
+}
+
+public fun CompilerConfiguration.addJvmClasspathRoots(files: List<File>): Unit = files.forEach { addJvmClasspathRoot(it) }
+
+public val CompilerConfiguration.jvmClasspathRoots: List<File>
+    get() {
+        return get(CommonConfigurationKeys.CONTENT_ROOTS)?.filterIsInstance<JvmClasspathRoot>()?.map { it.file } ?: emptyList()
+    }
+
+public fun CompilerConfiguration.addJavaSourceRoot(file: File) {
+    add(CommonConfigurationKeys.CONTENT_ROOTS, JavaSourceRoot(file))
+}
+
+public fun CompilerConfiguration.addJavaSourceRoots(files: List<File>): Unit = files.forEach { addJavaSourceRoot(it) }

compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/ReplInterpreter.java

@@ -35,7 +35,6 @@ import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.cli.common.messages.AnalyzerWithCompilerReport;
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector;
 import org.jetbrains.kotlin.cli.common.messages.MessageCollectorToString;
-import org.jetbrains.kotlin.cli.jvm.JVMConfigurationKeys;
 import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport;
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
@@ -80,6 +79,7 @@ import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 
+import static org.jetbrains.kotlin.cli.jvm.config.ConfigPackage.getJvmClasspathRoots;
 import static org.jetbrains.kotlin.codegen.AsmUtil.asmTypeByFqNameWithoutInnerClasses;
 import static org.jetbrains.kotlin.codegen.binding.CodegenBinding.registerClassNameForScript;
 import static org.jetbrains.kotlin.resolve.DescriptorToSourceUtils.descriptorToDeclaration;
@@ -154,7 +154,7 @@ public class ReplInterpreter {
         module.seal();
 
         List<URL> classpath = Lists.newArrayList();
-        for (File file : configuration.getList(JVMConfigurationKeys.CLASSPATH_KEY)) {
+        for (File file : getJvmClasspathRoots(configuration)) {
             try {
                 classpath.add(file.toURI().toURL());
             }

compiler/frontend/src/org/jetbrains/kotlin/config/CommonConfigurationKeys.java

@@ -24,7 +24,8 @@ public class CommonConfigurationKeys {
     private CommonConfigurationKeys() {
     }
 
-    public static final CompilerConfigurationKey<List<String>> SOURCE_ROOTS_KEY = CompilerConfigurationKey.create("source roots");
+    // roots, including dependencies and own source
+    public static final CompilerConfigurationKey<List<ContentRoot>> CONTENT_ROOTS = CompilerConfigurationKey.create("content roots");
 
     public static final CompilerConfigurationKey<List<JetScriptDefinition>> SCRIPT_DEFINITIONS_KEY = CompilerConfigurationKey.create("script definitions");
 }

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

@@ -0,0 +1,28 @@
+/*
+ * Copyright 2010-2015 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.config
+
+public trait ContentRoot
+
+public data class KotlinSourceRoot(public val path: String): ContentRoot
+
+public fun CompilerConfiguration.addKotlinSourceRoot(source: String) {
+    add(CommonConfigurationKeys.CONTENT_ROOTS, KotlinSourceRoot(source))
+}
+
+public fun CompilerConfiguration.addKotlinSourceRoots(sources: List<String>): Unit = sources.forEach { addKotlinSourceRoot(it) }
+

compiler/tests/org/jetbrains/kotlin/asJava/KotlinAsJavaTestBase.java

@@ -19,13 +19,14 @@ package org.jetbrains.kotlin.asJava;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
-import org.jetbrains.kotlin.config.CommonConfigurationKeys;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
 import org.jetbrains.kotlin.resolve.lazy.KotlinTestWithEnvironment;
 
 import java.io.File;
 import java.util.List;
 
+import static org.jetbrains.kotlin.config.ConfigPackage.addKotlinSourceRoot;
+
 public abstract class KotlinAsJavaTestBase extends KotlinTestWithEnvironment {
     protected JavaElementFinder finder;
 
@@ -34,7 +35,7 @@ public abstract class KotlinAsJavaTestBase extends KotlinTestWithEnvironment {
         CompilerConfiguration configuration = new CompilerConfiguration();
 
         for (File root : getKotlinSourceRoots()) {
-            configuration.add(CommonConfigurationKeys.SOURCE_ROOTS_KEY, root.getPath());
+            addKotlinSourceRoot(configuration, root.getPath());
         }
 
         extraConfiguration(configuration);

compiler/tests/org/jetbrains/kotlin/asJava/KotlinLightClassStructureTest.java

@@ -34,7 +34,7 @@ import java.util.List;
 import java.util.Set;
 
 import static org.jetbrains.kotlin.asJava.KotlinLightClassStructureTest.ClassProperty.*;
-import static org.jetbrains.kotlin.cli.jvm.JVMConfigurationKeys.CLASSPATH_KEY;
+import static org.jetbrains.kotlin.cli.jvm.config.ConfigPackage.addJvmClasspathRoot;
 
 @SuppressWarnings("JUnitTestClassNamingConvention")
 public abstract class KotlinLightClassStructureTest extends KotlinAsJavaTestBase {
@@ -149,7 +149,7 @@ public abstract class KotlinLightClassStructureTest extends KotlinAsJavaTestBase
 
         @Override
         protected void extraConfiguration(@NotNull CompilerConfiguration configuration) {
-            configuration.add(CLASSPATH_KEY, ForTestCompileRuntime.runtimeJarForTests());
+            addJvmClasspathRoot(configuration, ForTestCompileRuntime.runtimeJarForTests());
         }
     }
 

compiler/tests/org/jetbrains/kotlin/asJava/LightClassAnnotationsTest.java

@@ -21,7 +21,6 @@ import com.intellij.psi.PsiClass;
 import com.intellij.psi.PsiModifierList;
 import com.intellij.psi.search.GlobalSearchScope;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.cli.jvm.JVMConfigurationKeys;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
 import org.jetbrains.kotlin.test.JetTestUtils;
 
@@ -29,6 +28,8 @@ import java.io.File;
 import java.util.Collections;
 import java.util.List;
 
+import static org.jetbrains.kotlin.cli.jvm.config.ConfigPackage.addJvmClasspathRoot;
+
 public class LightClassAnnotationsTest extends KotlinAsJavaTestBase {
     private final File testDir = new File("compiler/testData/asJava/annotations");
 
@@ -39,7 +40,7 @@ public class LightClassAnnotationsTest extends KotlinAsJavaTestBase {
 
     @Override
     protected void extraConfiguration(@NotNull CompilerConfiguration configuration) {
-        configuration.add(JVMConfigurationKeys.CLASSPATH_KEY, JetTestUtils.getAnnotationsJar());
+        addJvmClasspathRoot(configuration, JetTestUtils.getAnnotationsJar());
     }
 
     public void testExtraAnnotations() throws Exception {

compiler/tests/org/jetbrains/kotlin/checkers/KotlinMultiFileTestWithWithJava.java

@@ -23,7 +23,6 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
-import org.jetbrains.kotlin.config.CommonConfigurationKeys;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
 import org.jetbrains.kotlin.test.ConfigurationKind;
 import org.jetbrains.kotlin.test.JetLiteFixture;
@@ -39,6 +38,8 @@ import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
+import static org.jetbrains.kotlin.config.ConfigPackage.addKotlinSourceRoot;
+
 public abstract class KotlinMultiFileTestWithWithJava<M, F> extends JetLiteFixture {
     protected class ModuleAndDependencies {
         final M module;
@@ -73,7 +74,7 @@ public abstract class KotlinMultiFileTestWithWithJava<M, F> extends JetLiteFixtu
         );
         File kotlinSourceRoot = getKotlinSourceRoot();
         if (kotlinSourceRoot != null) {
-            configuration.add(CommonConfigurationKeys.SOURCE_ROOTS_KEY, kotlinSourceRoot.getPath());
+            addKotlinSourceRoot(configuration, kotlinSourceRoot.getPath());
         }
         return createEnvironment(getTestRootDisposable(), configuration);
     }

compiler/tests/org/jetbrains/kotlin/codegen/AbstractTopLevelMembersInvocationTest.java

@@ -19,6 +19,7 @@ package org.jetbrains.kotlin.codegen;
 import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.util.ArrayUtil;
 import com.intellij.util.Processor;
+import kotlin.KotlinPackage;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
@@ -29,7 +30,6 @@ import org.jetbrains.kotlin.test.TestJdkKind;
 
 import java.io.File;
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 
@@ -69,7 +69,7 @@ public abstract class AbstractTopLevelMembersInvocationTest extends AbstractByte
         myEnvironment = KotlinCoreEnvironment.createForTests(
                 getTestRootDisposable(),
                 JetTestUtils.compilerConfigurationForTests(ConfigurationKind.JDK_ONLY, TestJdkKind.MOCK_JDK,
-                                                           Arrays.asList(JetTestUtils.getAnnotationsJar()), classPath),
+                                                           KotlinPackage.plus(classPath, JetTestUtils.getAnnotationsJar()), classPath),
                 EnvironmentConfigFiles.JVM_CONFIG_FILES);
 
         loadFiles(ArrayUtil.toStringArray(sourceFiles));

compiler/tests/org/jetbrains/kotlin/codegen/CodegenTestCase.java

@@ -22,8 +22,8 @@ import com.intellij.testFramework.TestDataFile;
 import com.intellij.testFramework.UsefulTestCase;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.backend.common.output.OutputFile;
-import org.jetbrains.kotlin.cli.jvm.JVMConfigurationKeys;
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
+import org.jetbrains.kotlin.cli.jvm.config.ConfigPackage;
 import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime;
 import org.jetbrains.kotlin.load.kotlin.PackagePartClassUtils;
 import org.jetbrains.kotlin.name.FqName;
@@ -49,6 +49,7 @@ import java.net.MalformedURLException;
 import java.net.URL;
 import java.util.List;
 
+import static org.jetbrains.kotlin.cli.jvm.config.ConfigPackage.getJvmClasspathRoots;
 import static org.jetbrains.kotlin.codegen.CodegenTestUtil.*;
 import static org.jetbrains.kotlin.load.kotlin.PackageClassUtils.getPackageClassFqName;
 
@@ -145,7 +146,7 @@ public abstract class CodegenTestCase extends UsefulTestCase {
     @NotNull
     protected URL[] getClassPathURLs() {
         List<URL> urls = Lists.newArrayList();
-        for (File file : myEnvironment.getConfiguration().getList(JVMConfigurationKeys.CLASSPATH_KEY)) {
+        for (File file : getJvmClasspathRoots(myEnvironment.getConfiguration())) {
             try {
                 urls.add(file.toURI().toURL());
             }

compiler/tests/org/jetbrains/kotlin/codegen/CodegenTestUtil.java

@@ -21,8 +21,8 @@ import kotlin.KotlinPackage;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.analyzer.AnalysisResult;
-import org.jetbrains.kotlin.cli.jvm.JVMConfigurationKeys;
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
+import org.jetbrains.kotlin.cli.jvm.config.JVMConfigurationKeys;
 import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
 import org.jetbrains.kotlin.codegen.state.Progress;

compiler/tests/org/jetbrains/kotlin/codegen/GenerateNotNullAssertionsTest.java

@@ -22,9 +22,9 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.backend.common.output.OutputFile;
 import org.jetbrains.kotlin.backend.common.output.OutputFileCollection;
 import org.jetbrains.kotlin.cli.common.output.outputUtils.OutputUtilsPackage;
-import org.jetbrains.kotlin.cli.jvm.JVMConfigurationKeys;
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
+import org.jetbrains.kotlin.cli.jvm.config.JVMConfigurationKeys;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
 import org.jetbrains.kotlin.load.kotlin.PackageClassUtils;
 import org.jetbrains.kotlin.name.FqName;

compiler/tests/org/jetbrains/kotlin/codegen/TestlibTest.java

@@ -24,14 +24,12 @@ import junit.framework.TestSuite;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys;
 import org.jetbrains.kotlin.cli.common.messages.MessageCollectorPlainTextToStream;
-import org.jetbrains.kotlin.cli.jvm.JVMConfigurationKeys;
 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.codegen.forTestCompile.ForTestCompileRuntime;
 import org.jetbrains.kotlin.codegen.state.GenerationState;
 import org.jetbrains.kotlin.codegen.state.JetTypeMapper;
-import org.jetbrains.kotlin.config.CommonConfigurationKeys;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
 import org.jetbrains.kotlin.descriptors.ClassDescriptor;
 import org.jetbrains.kotlin.psi.JetClass;
@@ -47,6 +45,8 @@ import org.jetbrains.kotlin.types.JetType;
 import java.io.File;
 import java.lang.reflect.Modifier;
 
+import static org.jetbrains.kotlin.cli.jvm.config.ConfigPackage.addJvmClasspathRoot;
+import static org.jetbrains.kotlin.config.ConfigPackage.addKotlinSourceRoot;
 import static org.jetbrains.kotlin.types.TypeUtils.getAllSupertypes;
 
 @SuppressWarnings("JUnitTestCaseWithNoTests")
@@ -83,14 +83,14 @@ public class TestlibTest extends UsefulTestCase {
         super.setUp();
 
         CompilerConfiguration configuration = JetTestUtils.compilerConfigurationForTests(ConfigurationKind.ALL, TestJdkKind.FULL_JDK);
-        configuration.add(JVMConfigurationKeys.CLASSPATH_KEY, JetTestUtils.getAnnotationsJar());
+        addJvmClasspathRoot(configuration, JetTestUtils.getAnnotationsJar());
 
         junitJar = new File("libraries/lib/junit-4.11.jar");
         assertTrue(junitJar.exists());
-        configuration.add(JVMConfigurationKeys.CLASSPATH_KEY, junitJar);
+        addJvmClasspathRoot(configuration, junitJar);
 
-        configuration.add(CommonConfigurationKeys.SOURCE_ROOTS_KEY, JetTestUtils.getHomeDirectory() + "/libraries/stdlib/test");
-        configuration.add(CommonConfigurationKeys.SOURCE_ROOTS_KEY, JetTestUtils.getHomeDirectory() + "/libraries/kunit/src");
+        addKotlinSourceRoot(configuration, JetTestUtils.getHomeDirectory() + "/libraries/stdlib/test");
+        addKotlinSourceRoot(configuration, JetTestUtils.getHomeDirectory() + "/libraries/kunit/src");
         configuration.put(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY,
                           new MessageCollectorPlainTextToStream(System.out, MessageCollectorPlainTextToStream.NON_VERBOSE));
 

compiler/tests/org/jetbrains/kotlin/codegen/generated/AbstractBlackBoxCodegenTest.java

@@ -22,7 +22,6 @@ import com.intellij.util.Processor;
 import kotlin.KotlinPackage;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.cli.common.output.outputUtils.OutputUtilsPackage;
-import org.jetbrains.kotlin.cli.jvm.JVMConfigurationKeys;
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.codegen.CodegenTestCase;
@@ -40,6 +39,7 @@ import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 
+import static org.jetbrains.kotlin.cli.jvm.config.ConfigPackage.addJvmClasspathRoot;
 import static org.jetbrains.kotlin.codegen.CodegenTestUtil.compileJava;
 import static org.jetbrains.kotlin.load.kotlin.PackageClassUtils.getPackageClassFqName;
 
@@ -126,7 +126,7 @@ public abstract class AbstractBlackBoxCodegenTest extends CodegenTestCase {
         CompilerConfiguration configuration = JetTestUtils.compilerConfigurationForTests(
                 ConfigurationKind.ALL, TestJdkKind.FULL_JDK, JetTestUtils.getAnnotationsJar()
         );
-        configuration.add(JVMConfigurationKeys.CLASSPATH_KEY, dirFile);
+        addJvmClasspathRoot(configuration, dirFile);
         myEnvironment = KotlinCoreEnvironment.createForTests(getTestRootDisposable(), configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES);
         loadFiles(ArrayUtil.toStringArray(ktFilePaths));
         classFileFactory =
@@ -137,7 +137,7 @@ public abstract class AbstractBlackBoxCodegenTest extends CodegenTestCase {
         // TODO: support several Java sources
         File javaOut = compileJava(KotlinPackage.single(javaFilePaths), kotlinOut.getPath());
         // Add javac output to classpath so that the created class loader can find generated Java classes
-        configuration.add(JVMConfigurationKeys.CLASSPATH_KEY, javaOut);
+        addJvmClasspathRoot(configuration, javaOut);
 
         blackBox();
     }

compiler/tests/org/jetbrains/kotlin/jvm/compiler/AbstractLoadJavaTest.java

@@ -21,11 +21,9 @@ import com.intellij.openapi.util.io.FileUtil;
 import junit.framework.ComparisonFailure;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.analyzer.AnalysisResult;
-import org.jetbrains.kotlin.cli.jvm.JVMConfigurationKeys;
 import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport;
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
-import org.jetbrains.kotlin.config.CommonConfigurationKeys;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
 import org.jetbrains.kotlin.descriptors.ClassDescriptor;
 import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
@@ -52,9 +50,14 @@ import org.junit.Assert;
 import java.io.File;
 import java.io.FileFilter;
 import java.io.IOException;
-import java.util.*;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
 import java.util.regex.Pattern;
 
+import static org.jetbrains.kotlin.cli.jvm.config.ConfigPackage.addJavaSourceRoot;
+import static org.jetbrains.kotlin.config.ConfigPackage.addKotlinSourceRoot;
 import static org.jetbrains.kotlin.jvm.compiler.LoadDescriptorUtil.*;
 import static org.jetbrains.kotlin.test.JetTestUtils.*;
 import static org.jetbrains.kotlin.test.util.DescriptorValidator.ValidationVisitor.errorTypesAllowed;
@@ -138,8 +141,8 @@ public abstract class AbstractLoadJavaTest extends TestCaseWithTmpdir {
 
         CompilerConfiguration configuration = JetTestUtils.compilerConfigurationForTests(
                 ConfigurationKind.JDK_ONLY, TestJdkKind.MOCK_JDK, tmpdir);
-        configuration.put(CommonConfigurationKeys.SOURCE_ROOTS_KEY, Arrays.asList(sourcesDir.getAbsolutePath()));
-        configuration.add(JVMConfigurationKeys.CLASSPATH_KEY, new File("compiler/tests")); // for @ExpectLoadError annotation
+        addKotlinSourceRoot(configuration, sourcesDir.getAbsolutePath());
+        addJavaSourceRoot(configuration, new File("compiler/tests")); // for @ExpectLoadError annotation
         KotlinCoreEnvironment environment =
                 KotlinCoreEnvironment.createForTests(getTestRootDisposable(), configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES);
 

compiler/tests/org/jetbrains/kotlin/jvm/compiler/JdkAnnotationsValidityTest.java

@@ -27,9 +27,9 @@ import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.openapi.vfs.VirtualFileManager;
 import com.intellij.openapi.vfs.VirtualFileVisitor;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.cli.jvm.JVMConfigurationKeys;
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles;
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
+import org.jetbrains.kotlin.cli.jvm.config.JVMConfigurationKeys;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
 import org.jetbrains.kotlin.name.FqName;
 import org.jetbrains.kotlin.test.ConfigurationKind;

compiler/tests/org/jetbrains/kotlin/jvm/compiler/MultiModuleJavaAnalysisCustomTest.kt

@@ -16,32 +16,32 @@
 
 package org.jetbrains.kotlin.jvm.compiler
 
-import org.jetbrains.kotlin.resolve.jvm.JvmAnalyzerFacade
-import org.jetbrains.kotlin.context.GlobalContext
-import org.jetbrains.kotlin.test.JetTestUtils
-import com.intellij.testFramework.UsefulTestCase
-import org.jetbrains.kotlin.resolve.jvm.JvmPlatformParameters
-import org.jetbrains.kotlin.psi.JetFile
-import java.io.File
-import com.intellij.psi.search.GlobalSearchScope
-import org.jetbrains.kotlin.name.Name
-import org.jetbrains.kotlin.name.FqName
-import org.jetbrains.kotlin.descriptors.*
-import org.junit.Assert
-import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
-import org.jetbrains.kotlin.config.CompilerConfiguration
-import org.jetbrains.kotlin.cli.jvm.JVMConfigurationKeys
-import com.intellij.psi.search.DelegatingGlobalSearchScope
 import com.intellij.openapi.vfs.VirtualFile
-import org.jetbrains.kotlin.builtins.KotlinBuiltIns
-import org.jetbrains.kotlin.resolve.jvm.JvmResolverForModule
-import org.jetbrains.kotlin.analyzer.ResolverForProject
-import org.jetbrains.kotlin.analyzer.ModuleInfo
-import java.util.HashMap
+import com.intellij.psi.search.DelegatingGlobalSearchScope
+import com.intellij.psi.search.GlobalSearchScope
+import com.intellij.testFramework.UsefulTestCase
 import org.jetbrains.kotlin.analyzer.ModuleContent
-import org.jetbrains.kotlin.types.ErrorUtils
-import org.jetbrains.kotlin.resolve.descriptorUtil.module
+import org.jetbrains.kotlin.analyzer.ModuleInfo
+import org.jetbrains.kotlin.analyzer.ResolverForProject
+import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
+import org.jetbrains.kotlin.cli.jvm.config.addJavaSourceRoots
+import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.context.GlobalContext
+import org.jetbrains.kotlin.descriptors.*
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.name.Name
+import org.jetbrains.kotlin.psi.JetFile
+import org.jetbrains.kotlin.resolve.descriptorUtil.module
+import org.jetbrains.kotlin.resolve.jvm.JvmAnalyzerFacade
+import org.jetbrains.kotlin.resolve.jvm.JvmPlatformParameters
+import org.jetbrains.kotlin.resolve.jvm.JvmResolverForModule
+import org.jetbrains.kotlin.test.JetTestUtils
+import org.jetbrains.kotlin.types.ErrorUtils
+import org.junit.Assert
+import java.io.File
+import java.util.HashMap
 
 public class MultiModuleJavaAnalysisCustomTest : UsefulTestCase() {
 
@@ -71,7 +71,7 @@ public class MultiModuleJavaAnalysisCustomTest : UsefulTestCase() {
 
     private fun createEnvironment(moduleDirs: Array<File>): KotlinCoreEnvironment {
         val configuration = CompilerConfiguration()
-        configuration.addAll(JVMConfigurationKeys.CLASSPATH_KEY, moduleDirs.toList())
+        configuration.addJavaSourceRoots(moduleDirs.toList())
         return KotlinCoreEnvironment.createForTests(getTestRootDisposable()!!, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES)
     }
 

compiler/tests/org/jetbrains/kotlin/scripts/ScriptTest.java

@@ -23,10 +23,10 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns;
 import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys;
 import org.jetbrains.kotlin.cli.common.messages.*;
-import org.jetbrains.kotlin.cli.jvm.JVMConfigurationKeys;
 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.JVMConfigurationKeys;
 import org.jetbrains.kotlin.codegen.CompilationException;
 import org.jetbrains.kotlin.config.CommonConfigurationKeys;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
@@ -45,6 +45,8 @@ import org.junit.Test;
 import java.util.Collections;
 import java.util.List;
 
+import static org.jetbrains.kotlin.config.ConfigPackage.addKotlinSourceRoot;
+
 public class ScriptTest {
     @Test
     public void testScript() throws Exception {
@@ -82,7 +84,7 @@ public class ScriptTest {
             CompilerConfiguration configuration =
                     JetTestUtils.compilerConfigurationForTests(ConfigurationKind.JDK_AND_ANNOTATIONS, TestJdkKind.FULL_JDK);
             configuration.put(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, messageCollector);
-            configuration.add(CommonConfigurationKeys.SOURCE_ROOTS_KEY, "compiler/testData/script/" + scriptPath);
+            addKotlinSourceRoot(configuration, "compiler/testData/script/" + scriptPath);
             configuration.addAll(CommonConfigurationKeys.SCRIPT_DEFINITIONS_KEY, scriptDefinitions);
             configuration.put(JVMConfigurationKeys.SCRIPT_PARAMETERS, scriptParameters);
 

compiler/tests/org/jetbrains/kotlin/serialization/js/KotlinJavascriptSerializerTest.kt

@@ -23,8 +23,8 @@ 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.config.CommonConfigurationKeys
 import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.config.addKotlinSourceRoots
 import org.jetbrains.kotlin.descriptors.impl.CompositePackageFragmentProvider
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
 import org.jetbrains.kotlin.js.analyze.TopDownAnalyzerFacadeForJS
@@ -52,8 +52,7 @@ public class KotlinJavascriptSerializerTest : TestCaseWithTmpdir() {
         val configuration = CompilerConfiguration()
         configuration.put(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, MessageCollector.NONE)
 
-        val sourceRoots = srcDirs map { it.path }
-        configuration.put(CommonConfigurationKeys.SOURCE_ROOTS_KEY, sourceRoots)
+        configuration.addKotlinSourceRoots(srcDirs map { it.path })
 
         serialize(configuration, metaFile)
         val module = deserialize(metaFile)

compiler/tests/org/jetbrains/kotlin/test/JetTestUtils.java

@@ -51,6 +51,8 @@ import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime;
 import org.jetbrains.kotlin.config.CommonConfigurationKeys;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
+import org.jetbrains.kotlin.config.ContentRoot;
+import org.jetbrains.kotlin.config.KotlinSourceRoot;
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl;
 import org.jetbrains.kotlin.diagnostics.Diagnostic;
 import org.jetbrains.kotlin.diagnostics.Errors;
@@ -85,8 +87,10 @@ import java.util.*;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
-import static org.jetbrains.kotlin.cli.jvm.JVMConfigurationKeys.ANNOTATIONS_PATH_KEY;
-import static org.jetbrains.kotlin.cli.jvm.JVMConfigurationKeys.CLASSPATH_KEY;
+import static org.jetbrains.kotlin.cli.jvm.config.ConfigPackage.addJavaSourceRoots;
+import static org.jetbrains.kotlin.cli.jvm.config.ConfigPackage.addJvmClasspathRoot;
+import static org.jetbrains.kotlin.cli.jvm.config.ConfigPackage.addJvmClasspathRoots;
+import static org.jetbrains.kotlin.cli.jvm.config.JVMConfigurationKeys.ANNOTATIONS_PATH_KEY;
 import static org.jetbrains.kotlin.jvm.compiler.LoadDescriptorUtil.compileKotlinToDirAndGetAnalysisResult;
 import static org.jetbrains.kotlin.psi.PsiPackage.JetPsiFactory;
 import static org.jetbrains.kotlin.test.ConfigurationKind.ALL;
@@ -407,25 +411,25 @@ public class JetTestUtils {
     public static CompilerConfiguration compilerConfigurationForTests(
             @NotNull ConfigurationKind configurationKind,
             @NotNull TestJdkKind jdkKind,
-            @NotNull Collection<File> extraClasspath,
-            @NotNull Collection<File> priorityClasspath
+            @NotNull List<File> classpath,
+            @NotNull List<File> javaSource
     ) {
         CompilerConfiguration configuration = new CompilerConfiguration();
-        configuration.addAll(CLASSPATH_KEY, priorityClasspath);
+        addJavaSourceRoots(configuration, javaSource);
         if (jdkKind == TestJdkKind.MOCK_JDK) {
-            configuration.add(CLASSPATH_KEY, findMockJdkRtJar());
+            addJvmClasspathRoot(configuration, findMockJdkRtJar());
         }
         else if (jdkKind == TestJdkKind.ANDROID_API) {
-            configuration.add(CLASSPATH_KEY, findAndroidApiJar());
+            addJvmClasspathRoot(configuration, findAndroidApiJar());
         }
         else {
-            configuration.addAll(CLASSPATH_KEY, PathUtil.getJdkClassesRoots());
+            addJvmClasspathRoots(configuration, PathUtil.getJdkClassesRoots());
         }
         if (configurationKind == ALL) {
-            configuration.add(CLASSPATH_KEY, ForTestCompileRuntime.runtimeJarForTests());
-            configuration.add(CLASSPATH_KEY, ForTestCompileRuntime.reflectJarForTests());
+            addJvmClasspathRoot(configuration, ForTestCompileRuntime.runtimeJarForTests());
+            addJvmClasspathRoot(configuration, ForTestCompileRuntime.reflectJarForTests());
         }
-        configuration.addAll(CLASSPATH_KEY, extraClasspath);
+        addJvmClasspathRoots(configuration, classpath);
 
         if (configurationKind == ALL || configurationKind == JDK_AND_ANNOTATIONS) {
             if (jdkKind == TestJdkKind.ANDROID_API) {
@@ -440,10 +444,13 @@ public class JetTestUtils {
     }
 
     public static void resolveAllKotlinFiles(KotlinCoreEnvironment environment) throws IOException {
-        List<String> paths = environment.getConfiguration().get(CommonConfigurationKeys.SOURCE_ROOTS_KEY);
+        List<ContentRoot> paths = environment.getConfiguration().get(CommonConfigurationKeys.CONTENT_ROOTS);
         if (paths == null) return;
         List<JetFile> jetFiles = Lists.newArrayList();
-        for (String path : paths) {
+        for (ContentRoot root : paths) {
+            if (!(root instanceof KotlinSourceRoot)) continue;
+
+            String path = ((KotlinSourceRoot) root).getPath();
             File file = new File(path);
             if (file.isFile()) {
                 jetFiles.add(loadJetFile(environment.getProject(), file));

libraries/stdlib/validator/src/test/kotlin/NoInternalVisibilityInStdLibTest.kt

@@ -20,7 +20,7 @@ import org.junit.Test
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
 import com.intellij.openapi.util.Disposer
-import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.config.*
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.descriptors.*
 import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils
@@ -32,7 +32,7 @@ import org.jetbrains.kotlin.utils.PathUtil
 import org.jetbrains.kotlin.resolve.DescriptorUtils
 import java.util.HashSet
 import org.jetbrains.kotlin.config.CommonConfigurationKeys
-import org.jetbrains.kotlin.cli.jvm.JVMConfigurationKeys
+import org.jetbrains.kotlin.cli.jvm.config.*
 import org.jetbrains.kotlin.resolve.jvm.TopDownAnalyzerFacadeForJVM
 import org.jetbrains.kotlin.builtins.KotlinBuiltIns
 import org.jetbrains.kotlin.resolve.BindingTraceContext
@@ -118,9 +118,9 @@ class NoInternalVisibilityInStdLibTest {
     Test fun testJvmStdlib() {
         doTest(ANALYZE_PACKAGE_ROOTS_FOR_JVM, ADDITIONALLY_REQUIRED_PACKAGES_FOR_JVM) {
             val configuration = CompilerConfiguration()
-            configuration.add(CommonConfigurationKeys.SOURCE_ROOTS_KEY, "../src/kotlin")
-            configuration.add(CommonConfigurationKeys.SOURCE_ROOTS_KEY, "../src/generated")
-            configuration.addAll(JVMConfigurationKeys.CLASSPATH_KEY, PathUtil.getJdkClassesRoots())
+            configuration.addKotlinSourceRoot("../src/kotlin")
+            configuration.addKotlinSourceRoot("../src/generated")
+            configuration.addJvmClasspathRoots(PathUtil.getJdkClassesRoots())
 
             val environment = KotlinCoreEnvironment.createForProduction(disposable!!, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES)
 

libraries/tools/kdoc/src/test/kotlin/test/kotlin/psiUtilsTest.kt

@@ -1,6 +1,6 @@
 package test.kotlin
 
-import org.jetbrains.kotlin.cli.jvm.JVMConfigurationKeys
+import org.jetbrains.kotlin.cli.jvm.config.*
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
 import org.jetbrains.kotlin.config.CompilerConfiguration
@@ -33,7 +33,7 @@ class PsiUtilsTest {
         System.setProperty("java.awt.headless", "true")
 
         val configuration = CompilerConfiguration()
-        configuration.addAll(JVMConfigurationKeys.CLASSPATH_KEY, PathUtil.getJdkClassesRoots())
+        configuration.addJvmClasspathRoots(PathUtil.getJdkClassesRoots())
         environment = KotlinCoreEnvironment.createForTests(rootDisposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES)
     }