JS: add suffix '_test' to test module output files to avoid name conflicts (KT-16979)

Also stop setting AMD module ids explicitly.

jps-plugin/jps-tests/test/org/jetbrains/kotlin/jps/build/KotlinJpsBuildTest.kt

@@ -133,8 +133,8 @@ class KotlinJpsBuildTest : AbstractKotlinJpsBuildTestCase() {
             val list = arrayListOf<String>()
             for (moduleName in moduleNames) {
                 val outputDir = File("out/production/$moduleName")
-                list.add(toSystemIndependentName(JpsJsModuleUtils.getOutputFile(outputDir, moduleName).path))
+                list.add(toSystemIndependentName(JpsJsModuleUtils.getOutputFile(outputDir, moduleName, false).path))
-                list.add(toSystemIndependentName(JpsJsModuleUtils.getOutputMetaFile(outputDir, moduleName).path))
+                list.add(toSystemIndependentName(JpsJsModuleUtils.getOutputMetaFile(outputDir, moduleName, false).path))
             }
             return list.toTypedArray()
         }
@@ -389,8 +389,7 @@ class KotlinJpsBuildTest : AbstractKotlinJpsBuildTestCase() {
         buildResult.assertSuccessful()
 
         val warnings = buildResult.getMessages(BuildMessage.Kind.WARNING)
-        assertEquals("Warning about duplicate module definition: $warnings", 1, warnings.size)
+        assertEquals("Warning about duplicate module definition: $warnings", 0, warnings.size)
-        assertEquals("Module \"srcAndTests\" is defined in more than one file", warnings[0].messageText)
     }
 
     fun testKotlinJavaScriptProjectWithTwoSrcModuleDependency() {

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

@@ -62,7 +62,7 @@ object JpsJsModuleUtils {
             fun addTarget(module: JpsModule, targetType: JavaModuleBuildTargetType) {
                 val moduleBuildTarget = ModuleBuildTarget(module, targetType)
                 val outputDir = KotlinBuilderModuleScriptGenerator.getOutputDirSafe(moduleBuildTarget)
-                val metaInfoFile = getOutputMetaFile(outputDir, module.name)
+                val metaInfoFile = getOutputMetaFile(outputDir, module.name, targetType.isTests)
                 if (metaInfoFile.exists()) {
                     result.add(metaInfoFile.absolutePath)
                 }
@@ -71,8 +71,12 @@ object JpsJsModuleUtils {
     }
 
     @JvmStatic
-    fun getOutputFile(outputDir: File, moduleName: String) = File(outputDir, moduleName + KotlinJavascriptMetadataUtils.JS_EXT)
+    fun getOutputFile(outputDir: File, moduleName: String, isTests: Boolean)
+            = File(outputDir, moduleName + suffix(isTests) + KotlinJavascriptMetadataUtils.JS_EXT)
 
     @JvmStatic
-    fun getOutputMetaFile(outputDir: File, moduleName: String) = File(outputDir, moduleName + KotlinJavascriptMetadataUtils.META_JS_SUFFIX)
+    fun getOutputMetaFile(outputDir: File, moduleName: String, isTests: Boolean)
+            = File(outputDir, moduleName + suffix(isTests) + KotlinJavascriptMetadataUtils.META_JS_SUFFIX)
+
+    private fun suffix(isTests: Boolean) = if (isTests) "_test" else ""
 }

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

@@ -294,7 +294,7 @@ class KotlinBuilder : ModuleLevelBuilder(BuilderCategory.SOURCE_PROCESSOR) {
         }
 
         if (JpsUtils.isJsKotlinModule(chunk.representativeTarget())) {
-            copyJsLibraryFilesIfNeeded(chunk, project)
+            copyJsLibraryFilesIfNeeded(chunk)
             return OK
         }
 
@@ -666,7 +666,7 @@ class KotlinBuilder : ModuleLevelBuilder(BuilderCategory.SOURCE_PROCESSOR) {
 
         val representativeModule = representativeTarget.module
         val moduleName = representativeModule.name
-        val outputFile = JpsJsModuleUtils.getOutputFile(outputDir, moduleName)
+        val outputFile = JpsJsModuleUtils.getOutputFile(outputDir, moduleName, representativeTarget.isTests)
         val libraries = JpsJsModuleUtils.getLibraryFilesAndDependencies(representativeTarget)
         val compilerSettings = JpsKotlinCompilerSettings.getCompilerSettings(representativeModule)
         val k2JsArguments = JpsKotlinCompilerSettings.getK2JsCompilerArguments(representativeModule)
@@ -676,7 +676,7 @@ class KotlinBuilder : ModuleLevelBuilder(BuilderCategory.SOURCE_PROCESSOR) {
         return environment.outputItemsCollector
     }
 
-    private fun copyJsLibraryFilesIfNeeded(chunk: ModuleChunk, project: JpsProject) {
+    private fun copyJsLibraryFilesIfNeeded(chunk: ModuleChunk) {
         val representativeTarget = chunk.representativeTarget()
         val outputDir = KotlinBuilderModuleScriptGenerator.getOutputDirSafe(representativeTarget)
         val compilerSettings = JpsKotlinCompilerSettings.getCompilerSettings(representativeTarget.module)

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

@@ -233,6 +233,13 @@ abstract class BasicBoxTest(
                                  "$KOTLIN_TEST_INTERNAL.endModule(\"${StringUtil.escapeStringCharacters(config.moduleId)}\");"
             FileUtil.writeToFile(outputFile, wrappedContent)
         }
+        else if (config.moduleKind == ModuleKind.AMD || config.moduleKind == ModuleKind.UMD) {
+            val content = FileUtil.loadFile(outputFile, true)
+            val wrappedContent = "if (typeof $KOTLIN_TEST_INTERNAL !== \"undefined\") { " +
+                                 "$KOTLIN_TEST_INTERNAL.setModuleId(\"${StringUtil.escapeStringCharacters(config.moduleId)}\"); }\n" +
+                                 "$content\n"
+            FileUtil.writeToFile(outputFile, wrappedContent)
+        }
 
         processJsProgram(translationResult.program, psiFiles)
     }

js/js.translator/src/org/jetbrains/kotlin/js/translate/general/ModuleWrapperTranslation.kt

@@ -28,7 +28,7 @@ object ModuleWrapperTranslation {
             program: JsProgram, kind: ModuleKind
     ): List<JsStatement> {
         return when (kind) {
-            ModuleKind.AMD -> wrapAmd(moduleId, function, importedModules, program)
+            ModuleKind.AMD -> wrapAmd(function, importedModules, program)
             ModuleKind.COMMON_JS -> wrapCommonJs(function, importedModules, program)
             ModuleKind.UMD -> wrapUmd(moduleId, function, importedModules, program)
             ModuleKind.PLAIN -> wrapPlain(moduleId, function, importedModules, program)
@@ -54,7 +54,7 @@ object ModuleWrapperTranslation {
                                      JsNameRef("amd", defineName.makeRef()))
         val commonJsTest = JsAstUtils.typeOfIs(exportsName.makeRef(), program.getStringLiteral("object"))
 
-        val amdBody = JsBlock(wrapAmd(moduleId, factoryName.makeRef(), importedModules, program))
+        val amdBody = JsBlock(wrapAmd(factoryName.makeRef(), importedModules, program))
         val commonJsBody = JsBlock(wrapCommonJs(factoryName.makeRef(), importedModules, program))
         val plainInvocation = makePlainInvocation(moduleId, factoryName.makeRef(), importedModules, program)
 
@@ -78,13 +78,12 @@ object ModuleWrapperTranslation {
     }
 
     private fun wrapAmd(
-            moduleId: String, function: JsExpression,
+            function: JsExpression,
             importedModules: List<StaticContext.ImportedModule>, program: JsProgram
     ): List<JsStatement> {
         val scope = program.scope
         val defineName = scope.declareName("define")
         val invocationArgs = listOf(
-                program.getStringLiteral(moduleId),
                 JsArrayLiteral(listOf(program.getStringLiteral("exports")) + importedModules.map { program.getStringLiteral(it.externalName) }),
                 function
         )

js/js.translator/testData/moduleEmulation.js

@@ -1,6 +1,8 @@
 
 var emulatedModules = { kotlin: kotlin };
 var module = { exports: {} };
+var currentModuleId;
+
 
 // TODO don't expose by default when run test with AMD module kind
 function require(moduleId) {
@@ -14,11 +16,19 @@ var $kotlin_test_internal$ = {
     },
     endModule : function(moduleId) {
         emulatedModules[moduleId] = module.exports;
+    },
+    setModuleId: function(moduleId) {
+        currentModuleId = moduleId;
     }
 };
 
 // TODO expose only when run test with AMD or UMD module kind
 function define(moduleId, dependencies, body) {
+    if (Array.isArray(moduleId)) {
+        body = dependencies;
+        dependencies = moduleId;
+        moduleId = currentModuleId;
+    }
     var resolvedDependencies = [];
     emulatedModules[moduleId] = {};
     for (var i = 0; i < dependencies.length; ++i) {