Rename ModuleScriptData -> ModuleChunk and refactor related code

Use the term "build file" instead of the old "module"/"module script"

compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/modules/ModuleChunk.java

@@ -22,12 +22,12 @@ import org.jetbrains.kotlin.modules.Module;
 import java.util.Collections;
 import java.util.List;
 
-public class ModuleScriptData {
+public class ModuleChunk {
-    public static final ModuleScriptData EMPTY = new ModuleScriptData(Collections.emptyList());
+    public static final ModuleChunk EMPTY = new ModuleChunk(Collections.emptyList());
 
     private final List<Module> modules;
 
-    public ModuleScriptData(@NotNull List<Module> modules) {
+    public ModuleChunk(@NotNull List<Module> modules) {
         this.modules = modules;
     }
 

compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/modules/ModuleXmlParser.java

@@ -22,7 +22,6 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector;
 import org.jetbrains.kotlin.cli.common.messages.MessageCollectorUtil;
-import org.jetbrains.kotlin.cli.common.messages.OutputMessageUtil;
 import org.jetbrains.kotlin.modules.JavaRootPath;
 import org.jetbrains.kotlin.modules.Module;
 import org.xml.sax.Attributes;
@@ -55,7 +54,7 @@ public class ModuleXmlParser {
     public static final String MODULAR_JDK_ROOT = "modularJdkRoot";
 
     @NotNull
-    public static ModuleScriptData parseModuleScript(
+    public static ModuleChunk parseModuleScript(
             @NotNull String xmlFile,
             @NotNull MessageCollector messageCollector
     ) {
@@ -67,7 +66,7 @@ public class ModuleXmlParser {
         }
         catch (FileNotFoundException e) {
             MessageCollectorUtil.reportException(messageCollector, e);
-            return ModuleScriptData.EMPTY;
+            return ModuleChunk.EMPTY;
         }
         finally {
             StreamUtil.closeStream(stream);
@@ -86,7 +85,7 @@ public class ModuleXmlParser {
         this.currentState = currentState;
     }
 
-    private ModuleScriptData parse(@NotNull InputStream xml) {
+    private ModuleChunk parse(@NotNull InputStream xml) {
         try {
             setCurrentState(initial);
             SAXParser saxParser = SAXParserFactory.newInstance().newSAXParser();
@@ -97,7 +96,7 @@ public class ModuleXmlParser {
                     return currentState;
                 }
             });
-            return new ModuleScriptData(modules);
+            return new ModuleChunk(modules);
         }
         catch (ParserConfigurationException | IOException e) {
             MessageCollectorUtil.reportException(messageCollector, e);
@@ -105,7 +104,7 @@ public class ModuleXmlParser {
         catch (SAXException e) {
             messageCollector.report(ERROR, "Build file does not have a valid XML: " + e, null);
         }
-        return ModuleScriptData.EMPTY;
+        return ModuleChunk.EMPTY;
     }
 
     private final DefaultHandler initial = new DefaultHandler() {

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

@@ -136,9 +136,6 @@ class K2JVMCompiler : CLICompiler<K2JVMCompilerArguments>() {
             val destination = arguments.destination
 
             if (arguments.buildFile != null) {
-                val sanitizedCollector = FilteringMessageCollector(messageCollector, VERBOSE::contains)
-                val moduleScript = CompileEnvironmentUtil.loadModuleDescriptions(arguments.buildFile, sanitizedCollector)
-
                 if (destination != null) {
                     messageCollector.report(
                             STRONG_WARNING,
@@ -146,11 +143,13 @@ class K2JVMCompiler : CLICompiler<K2JVMCompilerArguments>() {
                     )
                 }
 
-                val moduleFile = File(arguments.buildFile)
+                val sanitizedCollector = FilteringMessageCollector(messageCollector, VERBOSE::contains)
-                val directory = moduleFile.absoluteFile.parentFile
+                val buildFile = File(arguments.buildFile)
+                val moduleChunk = CompileEnvironmentUtil.loadModuleChunk(buildFile, sanitizedCollector)
 
-                KotlinToJVMBytecodeCompiler.configureSourceRoots(configuration, moduleScript.modules, directory)
+                configuration.put(JVMConfigurationKeys.MODULE_XML_FILE, buildFile)
-                configuration.put(JVMConfigurationKeys.MODULE_XML_FILE, moduleFile)
+
+                KotlinToJVMBytecodeCompiler.configureSourceRoots(configuration, moduleChunk.modules, buildFile)
 
                 val environment = createEnvironmentWithScriptingSupport(rootDisposable, configuration, arguments, messageCollector)
                                   ?: return COMPILATION_ERROR
@@ -159,7 +158,7 @@ class K2JVMCompiler : CLICompiler<K2JVMCompilerArguments>() {
                     if (!it) return COMPILATION_ERROR
                 }
 
-                KotlinToJVMBytecodeCompiler.compileModules(environment, directory)
+                KotlinToJVMBytecodeCompiler.compileModules(environment, buildFile, moduleChunk.modules)
             }
             else if (arguments.script) {
                 val sourcePath = arguments.freeArgs.first()

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

@@ -37,7 +37,7 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.backend.common.output.OutputFile;
 import org.jetbrains.kotlin.backend.common.output.OutputFileCollection;
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector;
-import org.jetbrains.kotlin.cli.common.modules.ModuleScriptData;
+import org.jetbrains.kotlin.cli.common.modules.ModuleChunk;
 import org.jetbrains.kotlin.cli.common.modules.ModuleXmlParser;
 import org.jetbrains.kotlin.config.CompilerConfiguration;
 import org.jetbrains.kotlin.config.JVMConfigurationKeys;
@@ -60,18 +60,16 @@ public class CompileEnvironmentUtil {
     private static final Logger LOG = Logger.getInstance(CompileEnvironmentUtil.class);
 
     @NotNull
-    public static ModuleScriptData loadModuleDescriptions(String moduleDefinitionFile, MessageCollector messageCollector) {
+    public static ModuleChunk loadModuleChunk(File buildFile, MessageCollector messageCollector) {
-        File file = new File(moduleDefinitionFile);
+        if (!buildFile.exists()) {
-        if (!file.exists()) {
+            messageCollector.report(ERROR, "Module definition file does not exist: " + buildFile, null);
-            messageCollector.report(ERROR, "Module definition file does not exist: " + moduleDefinitionFile, null);
+            return ModuleChunk.EMPTY;
-            return ModuleScriptData.EMPTY;
         }
-        String extension = FileUtilRt.getExtension(moduleDefinitionFile);
+        if ("xml".equalsIgnoreCase(FilesKt.getExtension(buildFile))) {
-        if ("xml".equalsIgnoreCase(extension)) {
+            return ModuleXmlParser.parseModuleScript(buildFile.getPath(), messageCollector);
-            return ModuleXmlParser.parseModuleScript(moduleDefinitionFile, messageCollector);
         }
-        messageCollector.report(ERROR, "Unknown module definition type: " + moduleDefinitionFile, null);
+        messageCollector.report(ERROR, "Unknown module definition type: " + buildFile, null);
-        return ModuleScriptData.EMPTY;
+        return ModuleChunk.EMPTY;
     }
 
     // TODO: includeRuntime should be not a flag but a path to runtime

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

@@ -66,13 +66,15 @@ import java.util.concurrent.TimeUnit
 
 object KotlinToJVMBytecodeCompiler {
 
-    private fun getAbsolutePaths(directory: File, module: Module): List<String> {
+    private fun getAbsolutePaths(buildFile: File, module: Module): List<String> {
         return module.getSourceFiles().map { sourceFile ->
-            var source = File(sourceFile)
+            val source = File(sourceFile)
             if (!source.isAbsolute) {
-                source = File(directory, sourceFile)
+                File(buildFile.absoluteFile.parentFile, sourceFile).absolutePath
+            }
+            else {
+                source.absolutePath
             }
-            source.absolutePath
         }
     }
 
@@ -111,13 +113,12 @@ object KotlinToJVMBytecodeCompiler {
         }
     }
 
-    fun compileModules(environment: KotlinCoreEnvironment, directory: File): Boolean {
+    internal fun compileModules(environment: KotlinCoreEnvironment, buildFile: File, chunk: List<Module>): Boolean {
         ProgressIndicatorAndCompilationCanceledStatus.checkCanceled()
 
         val moduleVisibilityManager = ModuleVisibilityManager.SERVICE.getInstance(environment.project)
 
         val projectConfiguration = environment.configuration
-        val chunk = projectConfiguration.getNotNull(JVMConfigurationKeys.MODULES)
         for (module in chunk) {
             moduleVisibilityManager.addModule(module)
         }
@@ -141,7 +142,7 @@ object KotlinToJVMBytecodeCompiler {
         for (module in chunk) {
             ProgressIndicatorAndCompilationCanceledStatus.checkCanceled()
             val ktFiles = CompileEnvironmentUtil.getKtFiles(
-                    environment.project, getAbsolutePaths(directory, module), projectConfiguration
+                    environment.project, getAbsolutePaths(buildFile, module), projectConfiguration
             ) { path -> throw IllegalStateException("Should have been checked before: $path") }
             if (!checkKotlinPackageUsage(environment, ktFiles)) return false
 
@@ -180,9 +181,9 @@ object KotlinToJVMBytecodeCompiler {
         }
     }
 
-    fun configureSourceRoots(configuration: CompilerConfiguration, chunk: List<Module>, directory: File) {
+    internal fun configureSourceRoots(configuration: CompilerConfiguration, chunk: List<Module>, buildFile: File) {
         for (module in chunk) {
-            configuration.addKotlinSourceRoots(getAbsolutePaths(directory, module))
+            configuration.addKotlinSourceRoots(getAbsolutePaths(buildFile, module))
         }
 
         for (module in chunk) {

compiler/tests/org/jetbrains/kotlin/modules/xml/AbstractModuleXmlParserTest.java

@@ -24,7 +24,7 @@ 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.messages.MessageRenderer;
-import org.jetbrains.kotlin.cli.common.modules.ModuleScriptData;
+import org.jetbrains.kotlin.cli.common.modules.ModuleChunk;
 import org.jetbrains.kotlin.cli.common.modules.ModuleXmlParser;
 import org.jetbrains.kotlin.modules.Module;
 import org.jetbrains.kotlin.test.KotlinTestUtils;
@@ -37,7 +37,7 @@ public abstract class AbstractModuleXmlParserTest extends TestCase {
     protected static void doTest(String xmlPath) throws IOException {
         File txtFile = new File(FileUtil.getNameWithoutExtension(xmlPath) + ".txt");
 
-        ModuleScriptData result = ModuleXmlParser.parseModuleScript(xmlPath, new MessageCollector() {
+        ModuleChunk result = ModuleXmlParser.parseModuleScript(xmlPath, new MessageCollector() {
             @Override
             public void report(
                     @NotNull CompilerMessageSeverity severity, @NotNull String message, @Nullable CompilerMessageLocation location