JS: use metadata in jps build process

jps-plugin/src/org/jetbrains/kotlin/jps/build/JpsJsModuleUtils.kt

@@ -17,46 +17,51 @@
 package org.jetbrains.kotlin.jps.build
 
 import com.intellij.util.Consumer
+import org.jetbrains.jps.builders.java.JavaModuleBuildTargetType
 import org.jetbrains.jps.incremental.ModuleBuildTarget
-import org.jetbrains.jps.model.java.JavaSourceRootProperties
-import org.jetbrains.jps.model.java.JavaSourceRootType
 import org.jetbrains.jps.model.java.JpsJavaModuleType
 import org.jetbrains.jps.model.library.JpsOrderRootType
 import org.jetbrains.jps.model.module.JpsModule
 import org.jetbrains.jps.util.JpsPathUtil
+import org.jetbrains.kotlin.utils.KotlinJavascriptMetadataUtils
+import java.io.File
 import java.util.ArrayList
+import kotlin.platform.platformStatic
 
-class JpsJsModuleUtils private() {
+object JpsJsModuleUtils {
-    companion object {
 
-        fun getLibraryFilesAndDependencies(target: ModuleBuildTarget): List<String> {
+    fun getLibraryFilesAndDependencies(target: ModuleBuildTarget): List<String> {
-            val result = ArrayList<String>()
+        val result = ArrayList<String>()
-            getLibraryFiles(target, result)
+        getLibraryFiles(target, result)
-            getDependencyModulesAndSources(target, result)
+        getDependencyModulesAndSources(target, result)
-            return result
+        return result
-        }
+    }
 
-        fun getLibraryFiles(target: ModuleBuildTarget, result: MutableList<String>) {
+    fun getLibraryFiles(target: ModuleBuildTarget, result: MutableList<String>) {
-            val libraries = JpsUtils.getAllDependencies(target).getLibraries()
+        val libraries = JpsUtils.getAllDependencies(target).getLibraries()
-            for (library in libraries) {
+        for (library in libraries) {
-                for (root in library.getRoots(JpsOrderRootType.COMPILED)) {
+            for (root in library.getRoots(JpsOrderRootType.COMPILED)) {
-                    result.add(JpsPathUtil.urlToPath(root.getUrl()))
+                result.add(JpsPathUtil.urlToPath(root.getUrl()))
-                }
             }
         }
-
-        fun getDependencyModulesAndSources(target: ModuleBuildTarget, result: MutableList<String>) {
-            JpsUtils.getAllDependencies(target).processModules(object : Consumer<JpsModule> {
-                override fun consume(module: JpsModule) {
-                    if (module == target.getModule() || module.getModuleType() != JpsJavaModuleType.INSTANCE) return
-
-                    result.add("@" + module.getName())
-
-                    for (root in module.getSourceRoots<JavaSourceRootProperties>(JavaSourceRootType.SOURCE)) {
-                        result.add(JpsPathUtil.urlToPath(root.getUrl()))
-                    }
-                }
-            })
-        }
     }
+
+    fun getDependencyModulesAndSources(target: ModuleBuildTarget, result: MutableList<String>) {
+        JpsUtils.getAllDependencies(target).processModules(object : Consumer<JpsModule> {
+            override fun consume(module: JpsModule) {
+                if (module == target.getModule() || module.getModuleType() != JpsJavaModuleType.INSTANCE) return
+
+                val moduleBuildTarget = ModuleBuildTarget(module, JavaModuleBuildTargetType.PRODUCTION)
+                val outputDir = KotlinBuilderModuleScriptGenerator.getOutputDirSafe(moduleBuildTarget)
+                val metaInfoFile = getOutputMetaFile(outputDir, module.getName())
+                result.add(metaInfoFile.getAbsolutePath())
+            }
+        })
+    }
+
+    platformStatic
+    fun getOutputFile(outputDir: File, moduleName: String) = File(outputDir, moduleName + KotlinJavascriptMetadataUtils.JS_EXT)
+
+    platformStatic
+    fun getOutputMetaFile(outputDir: File, moduleName: String) = File(outputDir, moduleName + KotlinJavascriptMetadataUtils.META_JS_SUFFIX)
 }

jps-plugin/src/org/jetbrains/kotlin/jps/build/KotlinBuilder.kt

@@ -399,8 +399,8 @@ public class KotlinBuilder : ModuleLevelBuilder(BuilderCategory.SOURCE_PROCESSOR
         val outputDir = KotlinBuilderModuleScriptGenerator.getOutputDirSafe(representativeTarget)
 
         val moduleName = representativeTarget.getModule().getName()
-        val outputFile = File(outputDir, "$moduleName.js")
+        val outputFile = JpsJsModuleUtils.getOutputFile(outputDir, moduleName)
-        val metaInfoFile = File(outputDir, "$moduleName.meta.js")
+        val metaInfoFile = JpsJsModuleUtils.getOutputMetaFile(outputDir, moduleName)
         val libraryFiles = JpsJsModuleUtils.getLibraryFilesAndDependencies(representativeTarget)
         val compilerSettings = JpsKotlinCompilerSettings.getCompilerSettings(project)
         val k2JsArguments = JpsKotlinCompilerSettings.getK2JsCompilerArguments(project)

js/js.frontend/src/org/jetbrains/kotlin/js/config/LibrarySourcesConfig.java

@@ -120,14 +120,8 @@ public class LibrarySourcesConfig extends Config {
         VirtualFileSystem fileSystem = VirtualFileManager.getInstance().getFileSystem(StandardFileSystems.FILE_PROTOCOL);
         VirtualFileSystem jarFileSystem = VirtualFileManager.getInstance().getFileSystem(StandardFileSystems.JAR_PROTOCOL);
 
-        String moduleName = null;
-
         for (String path : files) {
             VirtualFile file;
-            if (path.charAt(0) == '@') {
-                moduleName = path.substring(1);
-                continue;
-            }
 
             File filePath = new File(path);
             if (!filePath.exists()) {
@@ -149,10 +143,7 @@ public class LibrarySourcesConfig extends Config {
             else {
                 String actualModuleName;
 
-                if (moduleName != null) {
+                if (isOldKotlinJavascriptLibrary(filePath)) {
-                    actualModuleName = moduleName;
-                }
-                else if (isOldKotlinJavascriptLibrary(filePath)) {
                     actualModuleName = LibraryUtils.getKotlinJsModuleName(filePath);
                 }
                 else if (isKotlinJavascriptLibraryWithMetadata(filePath)) {
@@ -167,7 +158,6 @@ public class LibrarySourcesConfig extends Config {
                     action.invoke(actualModuleName, file);
                 }
             }
-            moduleName = null;
         }
 
         return false;

js/js.tests/test/org/jetbrains/kotlin/js/test/MultipleModulesTranslationTest.kt

@@ -16,6 +16,7 @@
 
 package org.jetbrains.kotlin.js.test
 
+import org.jetbrains.kotlin.js.JavaScript
 import org.jetbrains.kotlin.js.config.EcmaVersion
 import org.jetbrains.kotlin.js.facade.MainCallParameters
 import org.jetbrains.kotlin.js.test.rhino.RhinoFunctionResultChecker
@@ -52,12 +53,15 @@ public abstract class MultipleModulesTranslationTest(main: String) : BasicTest(m
         val fullFilePaths = getAllFilesInDir(pathToDir + File.separator + moduleName)
         val libraries = ArrayList<String>()
         for (dependencyName in dependencies) {
-            libraries.add("@" + dependencyName)
+            libraries.add(getMetaInfo(getModuleDirectoryName(dirName, dependencyName)))
-            libraries.add(pathToDir + File.separator + dependencyName)
         }
         generateJavaScriptFiles(fullFilePaths, moduleDirectoryName, MainCallParameters.noCall(), BasicTest.DEFAULT_ECMA_VERSIONS, moduleName, libraries)
     }
 
+    override fun getMetaInfo(moduleId: String): String? {
+        return getOutputPath() + moduleId + ".meta" + JavaScript.DOT_EXTENSION
+    }
+
     override fun additionalJsFiles(ecmaVersion: EcmaVersion): List<String> {
         val result = super.additionalJsFiles(ecmaVersion)
         val dirName = getTestName(true)