Move some configuration keys to JVM or to CommonConfigurationKeys

Move CONTENT_ROOTS and SCRIPT_DEFINITIONS_KEY to JVMConfigurationKeys because
they are only used on JVM, rename the latter to SCRIPT_DEFINITIONS.

Move MODULE_NAME to CommonConfigurationKeys to be combined with MODULE_ID in
JSConfigurationKeys in the future

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

@@ -29,6 +29,7 @@ import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment;
 import org.jetbrains.kotlin.codegen.CodegenTestFiles;
 import org.jetbrains.kotlin.codegen.GenerationUtils;
 import org.jetbrains.kotlin.codegen.forTestCompile.ForTestCompileRuntime;
+import org.jetbrains.kotlin.config.CommonConfigurationKeys;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
 import org.jetbrains.kotlin.config.JVMConfigurationKeys;
 import org.jetbrains.kotlin.idea.KotlinFileType;
@@ -158,7 +159,7 @@ public class CodegenTestsOnAndroidGenerator extends UsefulTestCase {
             TestJdkKind testJdkKind = isFullJdkAndRuntime ? TestJdkKind.FULL_JDK : TestJdkKind.MOCK_JDK;
             CompilerConfiguration configuration =
                     KotlinTestUtils.newConfiguration(configurationKind, testJdkKind, KotlinTestUtils.getAnnotationsJar());
-            configuration.put(JVMConfigurationKeys.MODULE_NAME, "android-module-" + MODULE_INDEX++);
+            configuration.put(CommonConfigurationKeys.MODULE_NAME, "android-module-" + MODULE_INDEX++);
             if (inheritMultifileParts) {
                 configuration.put(JVMConfigurationKeys.INHERIT_MULTIFILE_PARTS, true);
             }

compiler/backend/src/org/jetbrains/kotlin/codegen/state/GenerationState.kt

@@ -59,7 +59,7 @@ class GenerationState @JvmOverloads constructor(
         val generateDeclaredClassFilter: GenerateClassFilter = GenerationState.GenerateClassFilter.GENERATE_ALL,
         // For incremental compilation
         val targetId: TargetId? = null,
-        moduleName: String? = configuration.get(JVMConfigurationKeys.MODULE_NAME),
+        moduleName: String? = configuration.get(CommonConfigurationKeys.MODULE_NAME),
         // 'outDirectory' is a hack to correctly determine if a compiled class is from the same module as the callee during
         // partial compilation. Module chunks are treated as a single module.
         // TODO: get rid of it with the proper module infrastructure

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

@@ -108,14 +108,14 @@ class K2JVMCompiler : CLICompiler<K2JVMCompilerArguments>() {
 
         configuration.addJvmClasspathRoots(getClasspath(paths, arguments))
 
-        configuration.put(JVMConfigurationKeys.MODULE_NAME, arguments.moduleName ?: JvmAbi.DEFAULT_MODULE_NAME)
+        configuration.put(CommonConfigurationKeys.MODULE_NAME, arguments.moduleName ?: JvmAbi.DEFAULT_MODULE_NAME)
 
         if (arguments.module == null && arguments.freeArgs.isEmpty() && !arguments.version) {
             ReplFromTerminal.run(rootDisposable, configuration)
             return ExitCode.OK
         }
 
-        configuration.add(CommonConfigurationKeys.SCRIPT_DEFINITIONS_KEY, StandardScriptDefinition)
+        configuration.add(JVMConfigurationKeys.SCRIPT_DEFINITIONS, StandardScriptDefinition)
 
         if (arguments.skipMetadataVersionCheck) {
             JvmMetadataVersion.skipCheck = true

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

@@ -19,18 +19,18 @@ package org.jetbrains.kotlin.cli.jvm.compiler
 import com.intellij.openapi.vfs.VirtualFile
 import com.intellij.util.SmartList
 import org.jetbrains.kotlin.cli.jvm.config.JvmClasspathRoot
-import org.jetbrains.kotlin.config.CommonConfigurationKeys
+import org.jetbrains.kotlin.config.JVMConfigurationKeys
 import org.jetbrains.kotlin.descriptors.PackagePartProvider
 import org.jetbrains.kotlin.load.kotlin.ModuleMapping
 import java.io.EOFException
 
 class JvmPackagePartProvider(val env: KotlinCoreEnvironment) : PackagePartProvider {
     private val notLoadedRoots by lazy(LazyThreadSafetyMode.NONE) {
-        env.configuration.getList(CommonConfigurationKeys.CONTENT_ROOTS).
-                filterIsInstance<JvmClasspathRoot>().
-                mapNotNull {
-                    env.contentRootToVirtualFile(it)
-                }.filter { it.findChild("META-INF") != null }.toMutableList()
+        env.configuration.getList(JVMConfigurationKeys.CONTENT_ROOTS)
+                .filterIsInstance<JvmClasspathRoot>()
+                .mapNotNull { env.contentRootToVirtualFile(it) }
+                .filter { it.findChild("META-INF") != null }
+                .toMutableList()
     }
 
     private val loadedModules: MutableList<ModuleMapping> = SmartList()
@@ -52,7 +52,7 @@ class JvmPackagePartProvider(val env: KotlinCoreEnvironment) : PackagePartProvid
             pathParts.fold(it) {
                 parent, part ->
                 if (part.isEmpty()) parent
-                else  parent.findChild(part) ?: return@filter false
+                else parent.findChild(part) ?: return@filter false
             }
             true
         }
@@ -65,9 +65,10 @@ class JvmPackagePartProvider(val env: KotlinCoreEnvironment) : PackagePartProvid
         }.map {
             try {
                 ModuleMapping.create(it.contentsToByteArray())
-            } catch (e: EOFException) {
+            }
+            catch (e: EOFException) {
                 throw RuntimeException("Error on reading package parts for '$packageFqName' package in '$it', roots: $notLoadedRoots", e)
             }
         })
     }
-}
+}

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

@@ -70,8 +70,8 @@ import org.jetbrains.kotlin.cli.jvm.config.JvmContentRoot
 import org.jetbrains.kotlin.codegen.extensions.ClassBuilderInterceptorExtension
 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.JVMConfigurationKeys
 import org.jetbrains.kotlin.config.kotlinSourceRoots
 import org.jetbrains.kotlin.extensions.ExternalDeclarationsProvider
 import org.jetbrains.kotlin.extensions.StorageComponentContainerContributor
@@ -137,7 +137,9 @@ class KotlinCoreEnvironment private constructor(
             }
         })
 
-        KotlinScriptDefinitionProvider.getInstance(project).setScriptDefinitions(configuration.getList(CommonConfigurationKeys.SCRIPT_DEFINITIONS_KEY))
+        KotlinScriptDefinitionProvider.getInstance(project).setScriptDefinitions(
+                configuration.getList(JVMConfigurationKeys.SCRIPT_DEFINITIONS)
+        )
 
         project.registerService(JvmVirtualFileFinderFactory::class.java, JvmCliVirtualFileFinderFactory(index))
 
@@ -171,7 +173,7 @@ class KotlinCoreEnvironment private constructor(
             }
 
     private fun fillClasspath(configuration: CompilerConfiguration) {
-        for (root in configuration.getList(CommonConfigurationKeys.CONTENT_ROOTS)) {
+        for (root in configuration.getList(JVMConfigurationKeys.CONTENT_ROOTS)) {
             val javaRoot = root as? JvmContentRoot ?: continue
             val virtualFile = contentRootToVirtualFile(javaRoot) ?: continue
 

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

@@ -16,9 +16,9 @@
 
 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 org.jetbrains.kotlin.config.JVMConfigurationKeys
 import java.io.File
 
 data class JvmClasspathRoot(override val file: File): JvmContentRoot
@@ -30,18 +30,19 @@ interface JvmContentRoot : ContentRoot {
 }
 
 fun CompilerConfiguration.addJvmClasspathRoot(file: File) {
-    add(CommonConfigurationKeys.CONTENT_ROOTS, JvmClasspathRoot(file))
+    add(JVMConfigurationKeys.CONTENT_ROOTS, JvmClasspathRoot(file))
 }
 
 fun CompilerConfiguration.addJvmClasspathRoots(files: List<File>): Unit = files.forEach { addJvmClasspathRoot(it) }
 
 val CompilerConfiguration.jvmClasspathRoots: List<File>
     get() {
-        return get(CommonConfigurationKeys.CONTENT_ROOTS)?.filterIsInstance<JvmClasspathRoot>()?.map { it.file } ?: emptyList()
+        return get(JVMConfigurationKeys.CONTENT_ROOTS)?.filterIsInstance<JvmClasspathRoot>()?.map { it.file } ?: emptyList()
     }
 
 @JvmOverloads fun CompilerConfiguration.addJavaSourceRoot(file: File, packagePrefix: String? = null) {
-    add(CommonConfigurationKeys.CONTENT_ROOTS, JavaSourceRoot(file, packagePrefix))
+    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): Unit =
+        files.forEach { addJavaSourceRoot(it, packagePrefix) }

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

@@ -37,8 +37,8 @@ import org.jetbrains.kotlin.codegen.ClassBuilderFactories
 import org.jetbrains.kotlin.codegen.CompilationErrorHandler
 import org.jetbrains.kotlin.codegen.KotlinCodegenFacade
 import org.jetbrains.kotlin.codegen.state.GenerationState
-import org.jetbrains.kotlin.config.CommonConfigurationKeys
 import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.config.JVMConfigurationKeys
 import org.jetbrains.kotlin.descriptors.ScriptDescriptor
 import org.jetbrains.kotlin.idea.KotlinLanguage
 import org.jetbrains.kotlin.name.Name
@@ -68,7 +68,7 @@ class ReplInterpreter(
     }
 
     private val environment = run {
-        configuration.add(CommonConfigurationKeys.SCRIPT_DEFINITIONS_KEY, REPL_LINE_AS_SCRIPT_DEFINITION)
+        configuration.add(JVMConfigurationKeys.SCRIPT_DEFINITIONS, REPL_LINE_AS_SCRIPT_DEFINITION)
         KotlinCoreEnvironment.createForProduction(disposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES)
     }
 

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

@@ -16,19 +16,16 @@
 
 package org.jetbrains.kotlin.config
 
-import java.io.File
-
 interface ContentRoot
 
 data class KotlinSourceRoot(val path: String): ContentRoot
 
 fun CompilerConfiguration.addKotlinSourceRoot(source: String) {
-    add(CommonConfigurationKeys.CONTENT_ROOTS, KotlinSourceRoot(source))
+    add(JVMConfigurationKeys.CONTENT_ROOTS, KotlinSourceRoot(source))
 }
 
-fun CompilerConfiguration.addKotlinSourceRoots(sources: List<String>): Unit = sources.forEach { addKotlinSourceRoot(it) }
+fun CompilerConfiguration.addKotlinSourceRoots(sources: List<String>): Unit =
+        sources.forEach { addKotlinSourceRoot(it) }
 
 val CompilerConfiguration.kotlinSourceRoots: List<String>
-    get() {
-        return get(CommonConfigurationKeys.CONTENT_ROOTS)?.filterIsInstance<KotlinSourceRoot>()?.map { it.path } ?: emptyList()
-    }
+    get() = get(JVMConfigurationKeys.CONTENT_ROOTS)?.filterIsInstance<KotlinSourceRoot>()?.map { it.path }.orEmpty()

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

@@ -18,6 +18,7 @@ package org.jetbrains.kotlin.config;
 
 import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCompilationComponents;
 import org.jetbrains.kotlin.modules.Module;
+import org.jetbrains.kotlin.script.KotlinScriptDefinition;
 
 import java.io.File;
 import java.util.List;
@@ -26,6 +27,10 @@ public class JVMConfigurationKeys {
     private JVMConfigurationKeys() {
     }
 
+    // roots, including dependencies and own source
+    public static final CompilerConfigurationKey<List<ContentRoot>> CONTENT_ROOTS =
+            CompilerConfigurationKey.create("content roots");
+
     public static final CompilerConfigurationKey<File> OUTPUT_DIRECTORY =
             CompilerConfigurationKey.create("output directory");
     public static final CompilerConfigurationKey<File> OUTPUT_JAR =
@@ -33,6 +38,9 @@ public class JVMConfigurationKeys {
     public static final CompilerConfigurationKey<Boolean> INCLUDE_RUNTIME =
             CompilerConfigurationKey.create("include runtime to the resulting .jar");
 
+    public static final CompilerConfigurationKey<List<KotlinScriptDefinition>> SCRIPT_DEFINITIONS =
+            CompilerConfigurationKey.create("script definitions");
+
     public static final CompilerConfigurationKey<Boolean> DISABLE_CALL_ASSERTIONS =
             CompilerConfigurationKey.create("disable not-null call assertions");
     public static final CompilerConfigurationKey<Boolean> DISABLE_PARAM_ASSERTIONS =
@@ -58,7 +66,4 @@ public class JVMConfigurationKeys {
 
     public static final CompilerConfigurationKey<List<String>> FRIEND_PATHS =
             CompilerConfigurationKey.create("friend module paths");
-
-    public static final CompilerConfigurationKey<String> MODULE_NAME =
-            CompilerConfigurationKey.create("module name");
 }

compiler/frontend.java/src/org/jetbrains/kotlin/resolve/jvm/TopDownAnalyzerFacadeForJVM.java

@@ -20,6 +20,7 @@ import com.intellij.openapi.project.Project;
 import com.intellij.psi.search.GlobalSearchScope;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.kotlin.analyzer.AnalysisResult;
+import org.jetbrains.kotlin.config.CommonConfigurationKeys;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
 import org.jetbrains.kotlin.config.JVMConfigurationKeys;
 import org.jetbrains.kotlin.context.ContextKt;
@@ -144,7 +145,7 @@ public enum TopDownAnalyzerFacadeForJVM {
         ProjectContext projectContext = ContextKt.ProjectContext(project);
         JvmBuiltIns builtIns = new JvmBuiltIns(projectContext.getStorageManager());
         MutableModuleContext context = ContextKt.ContextForNewModule(
-                projectContext, Name.special("<" + configuration.getNotNull(JVMConfigurationKeys.MODULE_NAME) + ">"),
+                projectContext, Name.special("<" + configuration.getNotNull(CommonConfigurationKeys.MODULE_NAME) + ">"),
                 JvmPlatform.INSTANCE, builtIns
         );
         builtIns.setOwnerModuleDescriptor(context.getModule());

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

@@ -16,21 +16,13 @@
 
 package org.jetbrains.kotlin.config;
 
-import org.jetbrains.kotlin.script.KotlinScriptDefinition;
-
-import java.util.List;
-
 public class CommonConfigurationKeys {
     private CommonConfigurationKeys() {
     }
 
-    // roots, including dependencies and own source
-    public static final CompilerConfigurationKey<List<ContentRoot>> CONTENT_ROOTS =
-            CompilerConfigurationKey.create("content roots");
-
-    public static final CompilerConfigurationKey<List<KotlinScriptDefinition>> SCRIPT_DEFINITIONS_KEY =
-            CompilerConfigurationKey.create("script definitions");
-
     public static final CompilerConfigurationKey<Boolean> DISABLE_INLINE =
             CompilerConfigurationKey.create("disable inline");
+
+    public static final CompilerConfigurationKey<String> MODULE_NAME =
+            CompilerConfigurationKey.create("module name");
 }

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

@@ -420,7 +420,7 @@ public class KotlinTestUtils {
     @NotNull
     public static CompilerConfiguration newConfiguration() {
         CompilerConfiguration configuration = new CompilerConfiguration();
-        configuration.put(JVMConfigurationKeys.MODULE_NAME, TEST_MODULE_NAME);
+        configuration.put(CommonConfigurationKeys.MODULE_NAME, TEST_MODULE_NAME);
         return configuration;
     }
 
@@ -472,7 +472,7 @@ public class KotlinTestUtils {
     }
 
     public static void resolveAllKotlinFiles(KotlinCoreEnvironment environment) throws IOException {
-        List<ContentRoot> paths = environment.getConfiguration().get(CommonConfigurationKeys.CONTENT_ROOTS);
+        List<ContentRoot> paths = environment.getConfiguration().get(JVMConfigurationKeys.CONTENT_ROOTS);
         if (paths == null) return;
         List<KtFile> ktFiles = new ArrayList<KtFile>();
         for (ContentRoot root : paths) {

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

@@ -24,9 +24,9 @@ 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.config.ContentRootsKt;
+import org.jetbrains.kotlin.config.JVMConfigurationKeys;
 import org.jetbrains.kotlin.script.StandardScriptDefinition;
 import org.jetbrains.kotlin.test.ConfigurationKind;
 import org.jetbrains.kotlin.test.KotlinTestUtils;
@@ -63,7 +63,7 @@ public abstract class KotlinMultiFileTestWithJava<M, F> extends KotlinTestWithEn
                 CollectionsKt.plus(Collections.singletonList(KotlinTestUtils.getAnnotationsJar()), getExtraClasspath()),
                 Collections.singletonList(javaFilesDir)
         );
-        configuration.add(CommonConfigurationKeys.SCRIPT_DEFINITIONS_KEY, StandardScriptDefinition.INSTANCE);
+        configuration.add(JVMConfigurationKeys.SCRIPT_DEFINITIONS, StandardScriptDefinition.INSTANCE);
         if (isKotlinSourceRootNeeded()) {
             kotlinSourceRoot = KotlinTestUtils.tmpDir("kotlin-src");
             ContentRootsKt.addKotlinSourceRoot(configuration, kotlinSourceRoot.getPath());

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

@@ -27,9 +27,9 @@ 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.CompilationException;
-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.name.Name;
 import org.jetbrains.kotlin.script.KotlinScriptDefinition;
 import org.jetbrains.kotlin.script.ScriptParameter;
@@ -79,7 +79,7 @@ public class ScriptTest {
             CompilerConfiguration configuration = KotlinTestUtils.newConfiguration(ConfigurationKind.JDK_ONLY, TestJdkKind.FULL_JDK);
             configuration.put(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, messageCollector);
             ContentRootsKt.addKotlinSourceRoot(configuration, "compiler/testData/script/" + scriptPath);
-            configuration.add(CommonConfigurationKeys.SCRIPT_DEFINITIONS_KEY, scriptDefinition);
+            configuration.add(JVMConfigurationKeys.SCRIPT_DEFINITIONS, scriptDefinition);
 
             KotlinCoreEnvironment environment =
                     KotlinCoreEnvironment.createForProduction(rootDisposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES);