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