[JS IR] tests both per-module and regular mode

compiler/cli/cli-js/src/org/jetbrains/kotlin/cli/js/K2JsIrCompiler.kt

@@ -44,6 +44,7 @@ import org.jetbrains.kotlin.ir.backend.js.ic.*
 import org.jetbrains.kotlin.ir.backend.js.transformers.irToJs.IrModuleToJsTransformer
 import org.jetbrains.kotlin.ir.backend.js.transformers.irToJs.IrModuleToJsTransformerTmp
 import org.jetbrains.kotlin.ir.backend.js.transformers.irToJs.SourceMapsInfo
+import org.jetbrains.kotlin.ir.backend.js.transformers.irToJs.TranslationMode
 import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImpl
 import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImplForJsIC
 import org.jetbrains.kotlin.ir.declarations.persistent.PersistentIrFactory
@@ -283,9 +284,11 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {
                 val caches = loadModuleCaches(icCaches)
                 val moduleKind = configurationJs[JSConfigurationKeys.MODULE_KIND]!!
 
-                val compiledModule = generateJsFromAst(moduleName, moduleKind, SourceMapsInfo.from(configurationJs), caches)
+                val translationMode = TranslationMode.fromFlags(false, arguments.irPerModule)
 
-                val outputs = compiledModule.outputs!!
+                val compiledModule = generateJsFromAst(moduleName, moduleKind, SourceMapsInfo.from(configurationJs), setOf(translationMode), caches)
+
+                val outputs = compiledModule.outputs.values.single()
 
                 outputFile.write(outputs)
                 outputs.dependencies.forEach { (name, content) ->
@@ -408,18 +411,15 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {
                     val transformer = IrModuleToJsTransformerTmp(
                         ir.context,
                         mainCallArguments,
-                        fullJs = true,
-                        dceJs = arguments.irDce,
-                        multiModule = arguments.irPerModule,
                         relativeRequirePath = true,
                     )
 
-                    transformer.generateModule(ir.allModules)
+                    transformer.generateModule(ir.allModules, setOf(TranslationMode.fromFlags(arguments.irDce, arguments.irPerModule)))
                 } else {
                     val transformer = IrModuleToJsTransformer(
                         ir.context,
                         mainCallArguments,
-                        fullJs = true,
+                        fullJs = !arguments.irDce,
                         dceJs = arguments.irDce,
                         multiModule = arguments.irPerModule,
                         relativeRequirePath = true,
@@ -430,11 +430,7 @@ class K2JsIrCompiler : CLICompiler<K2JSCompilerArguments>() {
 
                 messageCollector.report(INFO, "Executable production duration: ${System.currentTimeMillis() - start}ms")
 
-
+                val outputs = compiledModule.outputs.values.single()
-                val outputs = if (arguments.irDce && !arguments.irDceDriven)
-                    compiledModule.outputsAfterDce!!
-                else
-                    compiledModule.outputs!!
 
                 outputFile.write(outputs)
                 outputs.dependencies.forEach { (name, content) ->

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/compiler.kt

@@ -16,6 +16,7 @@ import org.jetbrains.kotlin.ir.backend.js.lower.generateJsTests
 import org.jetbrains.kotlin.ir.backend.js.lower.moveBodilessDeclarationsToSeparatePlace
 import org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.JsIrLinker
 import org.jetbrains.kotlin.ir.backend.js.transformers.irToJs.IrModuleToJsTransformer
+import org.jetbrains.kotlin.ir.backend.js.transformers.irToJs.TranslationMode
 import org.jetbrains.kotlin.ir.backend.js.utils.NameTables
 import org.jetbrains.kotlin.ir.declarations.IrFactory
 import org.jetbrains.kotlin.ir.declarations.IrModuleFragment
@@ -30,8 +31,7 @@ import org.jetbrains.kotlin.js.config.RuntimeDiagnostic
 import org.jetbrains.kotlin.name.FqName
 
 class CompilerResult(
-    val outputs: CompilationOutputs?,
+    val outputs: Map<TranslationMode, CompilationOutputs>,
-    val outputsAfterDce: CompilationOutputs?,
     val tsDefinitions: String? = null
 )
 
@@ -228,5 +228,5 @@ fun generateJsCode(
     jsPhases.invokeToplevel(PhaseConfig(jsPhases), context, listOf(moduleFragment))
 
     val transformer = IrModuleToJsTransformer(context, null, true, nameTables)
-    return transformer.generateModule(listOf(moduleFragment)).outputs!!.jsCode
+    return transformer.generateModule(listOf(moduleFragment)).outputs[TranslationMode.FULL]!!.jsCode
 }

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/compilerWithIC.kt

@@ -92,9 +92,6 @@ fun compileWithIC(
     val transformer = IrModuleToJsTransformerTmp(
         context,
         mainArguments,
-        fullJs = generateFullJs,
-        dceJs = generateDceJs,
-        multiModule = multiModule,
         relativeRequirePath = relativeRequirePath,
     )
 
@@ -129,24 +126,28 @@ fun generateJsFromAst(
     mainModuleName: String,
     moduleKind: ModuleKind,
     sourceMapsInfo: SourceMapsInfo?,
+    translationModes: Set<TranslationMode>,
     caches: Map<String, ModuleCache>,
 ): CompilerResult {
-    val deserializer = JsIrAstDeserializer()
+    fun compilationOutput(multiModule: Boolean): CompilationOutputs {
-    val jsIrProgram = JsIrProgram(caches.values.map {
+        val deserializer = JsIrAstDeserializer()
-        JsIrModule(
+        val jsIrProgram = JsIrProgram(caches.values.map {
-            it.name.safeModuleName,
+            JsIrModule(
-            sanitizeName(it.name.safeModuleName),
+                it.name.safeModuleName,
-            it.asts.values.sortedBy { it.name }.mapNotNull { it.ast?.let { deserializer.deserialize(ByteArrayInputStream(it)) } })
+                sanitizeName(it.name.safeModuleName),
-    })
+                it.asts.values.sortedBy { it.name }.mapNotNull { it.ast?.let { deserializer.deserialize(ByteArrayInputStream(it)) } })
-    return CompilerResult(
+        })
-        generateWrappedModuleBody(
+
-            multiModule = true,
+        return generateWrappedModuleBody(
+            multiModule = multiModule,
             mainModuleName = mainModuleName,
             moduleKind = moduleKind,
             jsIrProgram,
             sourceMapsInfo = sourceMapsInfo,
             relativeRequirePath = false,
             generateScriptModule = false,
-        ), null
+        )
-    )
+    }
+
+    return CompilerResult(translationModes.associate { it to compilationOutput(it.perModule) }, null)
 }

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/transformers/irToJs/IrModuleToJsTransformer.kt

@@ -31,6 +31,7 @@ import org.jetbrains.kotlin.js.sourceMap.SourceMapBuilderConsumer
 import org.jetbrains.kotlin.js.util.TextOutputImpl
 import org.jetbrains.kotlin.utils.DFS
 import java.io.File
+import java.util.*
 
 class IrModuleToJsTransformer(
     private val backendContext: JsIrBackendContext,
@@ -65,18 +66,20 @@ class IrModuleToJsTransformer(
             namer.merge(module.files, additionalPackages)
         }
 
-        val jsCode = if (fullJs) generateWrappedModuleBody(modules, exportedModule, namer) else null
+        val code = EnumMap<TranslationMode, CompilationOutputs>(TranslationMode::class.java)
 
-        val dceJsCode = if (dceJs) {
+        if (fullJs) code[TranslationMode.fromFlags(false, multiModule)] = generateWrappedModuleBody(modules, exportedModule, namer)
+
+        if (dceJs) {
             eliminateDeadDeclarations(modules, backendContext, removeUnusedAssociatedObjects)
             // Use a fresh namer for DCE so that we could compare the result with DCE-driven
             // TODO: is this mode relevant for scripting? If yes, refactor so that the external name tables are used here when needed.
             val namer = NameTables(emptyList(), context = backendContext)
             namer.merge(modules.flatMap { it.files }, additionalPackages)
-            generateWrappedModuleBody(modules, exportedModule, namer)
+            code[TranslationMode.fromFlags(true, multiModule)] = generateWrappedModuleBody(modules, exportedModule, namer)
-        } else null
+        }
 
-        return CompilerResult(jsCode, dceJsCode, dts)
+        return CompilerResult(code, dts)
     }
 
     private fun generateWrappedModuleBody(modules: Iterable<IrModuleFragment>, exportedModule: ExportedModule, namer: NameTables): CompilationOutputs {

compiler/ir/backend.js/src/org/jetbrains/kotlin/ir/backend/js/transformers/irToJs/IrModuleToJsTransformerTmp.kt

@@ -30,15 +30,30 @@ import org.jetbrains.kotlin.js.util.TextOutputImpl
 import org.jetbrains.kotlin.serialization.js.ModuleKind
 import java.io.ByteArrayOutputStream
 import java.io.File
+import java.util.*
+
+enum class TranslationMode(val dce: Boolean, val perModule: Boolean) {
+    FULL(dce = false, perModule = false),
+    FULL_DCE(dce = true, perModule = false),
+    PER_MODULE(dce = false, perModule = true),
+    PER_MODULE_DCE(dce = true, perModule = true);
+
+    companion object {
+        fun fromFlags(dce: Boolean, perModule: Boolean): TranslationMode {
+            return if (perModule) {
+                if (dce) PER_MODULE_DCE else PER_MODULE
+            } else {
+                if (dce) FULL_DCE else FULL
+            }
+        }
+    }
+}
 
 class IrModuleToJsTransformerTmp(
     private val backendContext: JsIrBackendContext,
     private val mainArguments: List<String>?,
     private val generateScriptModule: Boolean = false,
     var namer: NameTables = NameTables(emptyList(), context = backendContext),
-    private val fullJs: Boolean = true,
-    private val dceJs: Boolean = false,
-    private val multiModule: Boolean = false,
     private val relativeRequirePath: Boolean = false,
     private val moduleToName: Map<IrModuleFragment, String> = emptyMap(),
     private val removeUnusedAssociatedObjects: Boolean = true,
@@ -48,7 +63,7 @@ class IrModuleToJsTransformerTmp(
     private val mainModuleName = backendContext.configuration[CommonConfigurationKeys.MODULE_NAME]!!
     private val moduleKind = backendContext.configuration[JSConfigurationKeys.MODULE_KIND]!!
 
-    fun generateModule(modules: Iterable<IrModuleFragment>): CompilerResult {
+    fun generateModule(modules: Iterable<IrModuleFragment>, modes: Set<TranslationMode>): CompilerResult {
         val exportModelGenerator = ExportModelGenerator(backendContext, generateNamespacesForPackages = true)
 
         val exportData = modules.associate { module ->
@@ -63,7 +78,7 @@ class IrModuleToJsTransformerTmp(
             module.files.forEach { StaticMembersLowering(backendContext).lower(it) }
         }
 
-        val jsCode = if (fullJs) generateWrappedModuleBody(
+        fun compilationOutput(multiModule: Boolean) = generateWrappedModuleBody(
             multiModule,
             mainModuleName,
             moduleKind,
@@ -71,23 +86,23 @@ class IrModuleToJsTransformerTmp(
             SourceMapsInfo.from(backendContext.configuration),
             relativeRequirePath,
             generateScriptModule,
-        ) else null
+        )
 
-        val dceJsCode = if (dceJs) {
+        val result = EnumMap<TranslationMode, CompilationOutputs>(TranslationMode::class.java)
+
+        modes.filter { !it.dce }.forEach {
+            result[it] = compilationOutput(it.perModule)
+        }
+
+        if (modes.any { it.dce }) {
             eliminateDeadDeclarations(modules, backendContext, removeUnusedAssociatedObjects)
+        }
 
-            generateWrappedModuleBody(
+        modes.filter { it.dce }.forEach {
-                multiModule,
+            result[it] = compilationOutput(it.perModule)
-                mainModuleName,
+        }
-                moduleKind,
-                generateProgramFragments(modules, exportData),
-                SourceMapsInfo.from(backendContext.configuration),
-                relativeRequirePath,
-                generateScriptModule,
-            )
-        } else null
 
-        return CompilerResult(jsCode, dceJsCode, dts)
+        return CompilerResult(result, dts)
     }
 
     fun generateBinaryAst(files: Iterable<IrFile>): Map<String, ByteArray> {

compiler/tests-common-new/tests/org/jetbrains/kotlin/test/services/configuration/JsEnvironmentConfigurator.kt

@@ -14,6 +14,7 @@ import org.jetbrains.kotlin.config.CommonConfigurationKeys
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.config.LanguageVersion
 import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl
+import org.jetbrains.kotlin.ir.backend.js.transformers.irToJs.TranslationMode
 import org.jetbrains.kotlin.js.config.*
 import org.jetbrains.kotlin.js.facade.MainCallParameters
 import org.jetbrains.kotlin.library.KotlinLibrary
@@ -52,10 +53,14 @@ class JsEnvironmentConfigurator(testServices: TestServices) : EnvironmentConfigu
         const val TEST_DATA_DIR_PATH = "js/js.translator/testData"
         const val OLD_MODULE_SUFFIX = "_old"
 
-        private const val OUTPUT_DIR_NAME = "outputDir"
+        private val outputDirByMode = mapOf(
-        private const val RECOMPILED_OUTPUT_DIR_NAME = "outputDir-recompiled"
+            TranslationMode.FULL to "outputDir",
+            TranslationMode.FULL_DCE to "dceOutputDir",
+            TranslationMode.PER_MODULE to "perModuleOutputDir",
+            TranslationMode.PER_MODULE_DCE to "perModuleDceOutputDir"
+        )
+
         private const val OUTPUT_KLIB_DIR_NAME = "outputKlibDir"
-        private const val DCE_OUTPUT_DIR_NAME = "dceOutputDir"
         private const val MINIFICATION_OUTPUT_DIR_NAME = "minOutputDir"
 
         object ExceptionThrowingReporter : JsConfig.Reporter() {
@@ -77,38 +82,30 @@ class JsEnvironmentConfigurator(testServices: TestServices) : EnvironmentConfigu
             return testName + outputFileSuffix
         }
 
-        fun getJsModuleArtifactPath(testServices: TestServices, moduleName: String): String {
+        fun getJsModuleArtifactPath(testServices: TestServices, moduleName: String, translationMode: TranslationMode = TranslationMode.FULL): String {
-            return getJsArtifactsOutputDir(testServices).absolutePath + File.separator + getJsArtifactSimpleName(testServices, moduleName) + "_v5"
+            return getJsArtifactsOutputDir(testServices, translationMode).absolutePath + File.separator + getJsArtifactSimpleName(testServices, moduleName) + "_v5"
         }
 
-        fun getRecompiledJsModuleArtifactPath(testServices: TestServices, moduleName: String): String {
+        fun getRecompiledJsModuleArtifactPath(testServices: TestServices, moduleName: String, translationMode: TranslationMode = TranslationMode.FULL): String {
-            return getJsArtifactsRecompiledOutputDir(testServices).absolutePath + File.separator + getJsArtifactSimpleName(testServices, moduleName) + "_v5"
+            return getJsArtifactsRecompiledOutputDir(testServices, translationMode).absolutePath + File.separator + getJsArtifactSimpleName(testServices, moduleName) + "_v5"
         }
 
         fun getJsKlibArtifactPath(testServices: TestServices, moduleName: String): String {
             return getJsKlibOutputDir(testServices).absolutePath + File.separator + getJsArtifactSimpleName(testServices, moduleName)
         }
 
-        fun getDceJsArtifactPath(testServices: TestServices, moduleName: String): String {
+        fun getJsArtifactsOutputDir(testServices: TestServices, translationMode: TranslationMode = TranslationMode.FULL): File {
-            return getDceJsArtifactsOutputDir(testServices).absolutePath + File.separator + getJsArtifactSimpleName(testServices, moduleName) + "_v5"
+            return testServices.temporaryDirectoryManager.getOrCreateTempDirectory(outputDirByMode[translationMode]!!)
         }
 
-        fun getJsArtifactsOutputDir(testServices: TestServices): File {
+        fun getJsArtifactsRecompiledOutputDir(testServices: TestServices, translationMode: TranslationMode = TranslationMode.FULL): File {
-            return testServices.temporaryDirectoryManager.getOrCreateTempDirectory(OUTPUT_DIR_NAME)
+            return testServices.temporaryDirectoryManager.getOrCreateTempDirectory(outputDirByMode[translationMode]!! + "-recompiled")
-        }
-
-        fun getJsArtifactsRecompiledOutputDir(testServices: TestServices): File {
-            return testServices.temporaryDirectoryManager.getOrCreateTempDirectory(RECOMPILED_OUTPUT_DIR_NAME)
         }
 
         fun getJsKlibOutputDir(testServices: TestServices): File {
             return testServices.temporaryDirectoryManager.getOrCreateTempDirectory(OUTPUT_KLIB_DIR_NAME)
         }
 
-        fun getDceJsArtifactsOutputDir(testServices: TestServices): File {
-            return testServices.temporaryDirectoryManager.getOrCreateTempDirectory(DCE_OUTPUT_DIR_NAME)
-        }
-
         fun getMinificationJsArtifactsOutputDir(testServices: TestServices): File {
             return testServices.temporaryDirectoryManager.getOrCreateTempDirectory(MINIFICATION_OUTPUT_DIR_NAME)
         }

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

@@ -13,6 +13,7 @@ import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.ir.backend.js.*
 import org.jetbrains.kotlin.ir.backend.js.codegen.JsGenerationGranularity
 import org.jetbrains.kotlin.ir.backend.js.transformers.irToJs.IrModuleToJsTransformerTmp
+import org.jetbrains.kotlin.ir.backend.js.transformers.irToJs.TranslationMode
 import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImpl
 import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImplForJsIC
 import org.jetbrains.kotlin.js.config.JSConfigurationKeys
@@ -45,15 +46,12 @@ abstract class AbstractJsKLibABITestCase : AbstractKlibABITestCase() {
         val transformer = IrModuleToJsTransformerTmp(
             ir.context,
             emptyList(),
-            fullJs = true,
-            dceJs = true,
-            multiModule = true,
             relativeRequirePath = false
         )
 
-        val compiledResult = transformer.generateModule(ir.allModules)
+        val compiledResult = transformer.generateModule(ir.allModules, setOf(TranslationMode.FULL_DCE))
 
-        val dceOutput = compiledResult.outputsAfterDce ?: error("No DCE output")
+        val dceOutput = compiledResult.outputs[TranslationMode.FULL_DCE] ?: error("No DCE output")
 
         val binariesDir = File(buildDir, BIN_DIR_NAME).also { it.mkdirs() }
 

js/js.tests/test/org/jetbrains/kotlin/js/test/converters/JsIrBackendFacade.kt

@@ -19,7 +19,7 @@ import org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.JsManglerDesc
 import org.jetbrains.kotlin.ir.backend.js.transformers.irToJs.IrModuleToJsTransformer
 import org.jetbrains.kotlin.ir.backend.js.transformers.irToJs.IrModuleToJsTransformerTmp
 import org.jetbrains.kotlin.ir.backend.js.transformers.irToJs.SourceMapsInfo
-import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImpl
+import org.jetbrains.kotlin.ir.backend.js.transformers.irToJs.TranslationMode
 import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImplForJsIC
 import org.jetbrains.kotlin.ir.util.IrMessageLogger
 import org.jetbrains.kotlin.ir.util.SymbolTable
@@ -98,10 +98,11 @@ class JsIrBackendFacade(
             val moduleName = configuration.getNotNull(CommonConfigurationKeys.MODULE_NAME)
             val moduleKind = configuration.get(JSConfigurationKeys.MODULE_KIND, ModuleKind.PLAIN)
             val sourceMapsInfo = SourceMapsInfo.from(configuration)
-            val compiledModule = generateJsFromAst(moduleName, moduleKind, sourceMapsInfo, testServices.jsIrIncrementalDataProvider.getCaches())
+            val translationModes = setOf(TranslationMode.FULL, TranslationMode.PER_MODULE)
+            val compiledModule = generateJsFromAst(moduleName, moduleKind, sourceMapsInfo, translationModes, testServices.jsIrIncrementalDataProvider.getCaches())
             return BinaryArtifacts.Js.JsIrArtifact(
                 outputFile, compiledModule, testServices.jsIrIncrementalDataProvider.getCacheForModule(module)
-            ).dump(module)
+            ).dump(module, firstTimeCompilation)
         }
 
         val loweredIr = compileIr(
@@ -140,21 +141,23 @@ class JsIrBackendFacade(
         val runIrDce = JsEnvironmentConfigurationDirectives.RUN_IR_DCE in module.directives
         val esModules = JsEnvironmentConfigurationDirectives.ES_MODULES in module.directives
         val runNewIr2Js = JsEnvironmentConfigurationDirectives.RUN_NEW_IR_2_JS in module.directives
+        val perModuleOnly = JsEnvironmentConfigurationDirectives.SPLIT_PER_MODULE in module.directives
 
-        val outputFile = File(JsEnvironmentConfigurator.getJsModuleArtifactPath(testServices, module.name) + ".js")
+        val outputFile = File(JsEnvironmentConfigurator.getJsModuleArtifactPath(testServices, module.name, TranslationMode.FULL) + ".js")
-        val dceOutputFile = File(JsEnvironmentConfigurator.getDceJsArtifactPath(testServices, module.name) + ".js")
+        val dceOutputFile = File(JsEnvironmentConfigurator.getJsModuleArtifactPath(testServices, module.name, TranslationMode.FULL_DCE) + ".js")
         if (!esModules) {
             if (runNewIr2Js) {
                 val transformer = IrModuleToJsTransformerTmp(
                     loweredIr.context,
                     mainArguments,
-                    fullJs = true,
-                    dceJs = runIrDce,
-                    multiModule = granularity == JsGenerationGranularity.PER_MODULE,
                     relativeRequirePath = false
                 )
 
-                return BinaryArtifacts.Js.JsIrArtifact(outputFile, transformer.generateModule(loweredIr.allModules)).dump(module)
+                // If runIrDce then include DCE results
+                // If perModuleOnly then skip whole program
+                // (it.dce => runIrDce) && (perModuleOnly => it.perModule)
+                val translationModes = TranslationMode.values().filter { (!it.dce || runIrDce) && (!perModuleOnly || it.perModule) }.toSet()
+                return BinaryArtifacts.Js.JsIrArtifact(outputFile, transformer.generateModule(loweredIr.allModules, translationModes)).dump(module)
             } else {
                 val transformer = IrModuleToJsTransformer(
                     loweredIr.context,
@@ -257,18 +260,23 @@ class JsIrBackendFacade(
         }
     }
 
-    private fun BinaryArtifacts.Js.JsIrArtifact.dump(module: TestModule): BinaryArtifacts.Js.JsIrArtifact {
+    private fun BinaryArtifacts.Js.JsIrArtifact.dump(module: TestModule, firstTimeCompilation: Boolean = true): BinaryArtifacts.Js.JsIrArtifact {
         val configuration = testServices.compilerConfigurationProvider.getCompilerConfiguration(module)
         val moduleId = configuration.getNotNull(CommonConfigurationKeys.MODULE_NAME)
         val moduleKind = configuration.get(JSConfigurationKeys.MODULE_KIND, ModuleKind.PLAIN)
-        val outputDceFile = File(JsEnvironmentConfigurator.getDceJsArtifactPath(testServices, module.name) + ".js")
 
         val generateDts = JsEnvironmentConfigurationDirectives.GENERATE_DTS in module.directives
         val dontSkipRegularMode = JsEnvironmentConfigurationDirectives.SKIP_REGULAR_MODE !in module.directives
 
         if (dontSkipRegularMode) {
-            compilerResult.outputs!!.writeTo(outputFile, moduleId, moduleKind)
+            for ((mode, output) in compilerResult.outputs.entries) {
-            compilerResult.outputsAfterDce?.writeTo(outputDceFile, moduleId, moduleKind)
+                val outputFile = if (firstTimeCompilation) {
+                    File(JsEnvironmentConfigurator.getJsModuleArtifactPath(testServices, module.name, mode) + ".js")
+                } else {
+                    File(JsEnvironmentConfigurator.getRecompiledJsModuleArtifactPath(testServices, module.name, mode) + ".js")
+                }
+                output.writeTo(outputFile, moduleId, moduleKind)
+            }
         }
 
         if (generateDts) {
@@ -328,7 +336,9 @@ class JsIrBackendFacade(
     }
 }
 
-fun File.augmentWithModuleName(moduleName: String): File {
+fun String.augmentWithModuleName(moduleName: String): String {
-    check(absolutePath.endsWith("_v5.js"))
+    check(endsWith("_v5.js"))
-    return File(absolutePath.removeSuffix("_v5.js") + "-${moduleName}_v5.js")
+    return removeSuffix("_v5.js") + "-${moduleName}_v5.js"
-}
+}
+
+fun File.augmentWithModuleName(moduleName: String): File = File(absolutePath.augmentWithModuleName(moduleName))

js/js.tests/test/org/jetbrains/kotlin/js/test/handlers/JsArtifactsDumpHandler.kt

@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.js.test.handlers
 
+import org.jetbrains.kotlin.ir.backend.js.transformers.irToJs.TranslationMode
 import org.jetbrains.kotlin.test.backend.handlers.JsBinaryArtifactHandler
 import org.jetbrains.kotlin.test.directives.JsEnvironmentConfigurationDirectives
 import org.jetbrains.kotlin.test.model.BinaryArtifacts
@@ -28,13 +29,19 @@ class JsArtifactsDumpHandler(testServices: TestServices) : JsBinaryArtifactHandl
 
         val testGroupOutputDirForCompilation = File(pathToRootOutputDir + "out/" + testGroupOutputDirPrefix)
         val testGroupOutputDirForMinification = File(pathToRootOutputDir + "out-min/" + testGroupOutputDirPrefix)
+        val testGroupOutputDirForPerModuleCompilation = File(pathToRootOutputDir + "out-per-module/" + testGroupOutputDirPrefix)
+        val testGroupOutputDirForPerModuleMinification = File(pathToRootOutputDir + "out-per-module-min/" + testGroupOutputDirPrefix)
 
         val outputDir = getOutputDir(originalFile, testGroupOutputDirForCompilation, stopFile)
         val dceOutputDir = getOutputDir(originalFile, testGroupOutputDirForMinification, stopFile)
+        val perModuleOutputDir = getOutputDir(originalFile, testGroupOutputDirForPerModuleCompilation, stopFile)
+        val preModuleDceOutputDir = getOutputDir(originalFile, testGroupOutputDirForPerModuleMinification, stopFile)
         val minOutputDir = File(dceOutputDir, originalFile.nameWithoutExtension)
 
         copy(JsEnvironmentConfigurator.getJsArtifactsOutputDir(testServices), outputDir)
-        copy(JsEnvironmentConfigurator.getDceJsArtifactsOutputDir(testServices), dceOutputDir)
+        copy(JsEnvironmentConfigurator.getJsArtifactsOutputDir(testServices, TranslationMode.FULL_DCE), dceOutputDir)
+        copy(JsEnvironmentConfigurator.getJsArtifactsOutputDir(testServices, TranslationMode.PER_MODULE), perModuleOutputDir)
+        copy(JsEnvironmentConfigurator.getJsArtifactsOutputDir(testServices, TranslationMode.PER_MODULE_DCE), preModuleDceOutputDir)
         copy(JsEnvironmentConfigurator.getMinificationJsArtifactsOutputDir(testServices), minOutputDir)
     }
 

js/js.tests/test/org/jetbrains/kotlin/js/test/handlers/JsAstHandler.kt

@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.js.test.handlers
 
+import org.jetbrains.kotlin.ir.backend.js.transformers.irToJs.TranslationMode
 import org.jetbrains.kotlin.js.backend.ast.JsExpressionStatement
 import org.jetbrains.kotlin.js.backend.ast.JsNullLiteral
 import org.jetbrains.kotlin.js.backend.ast.JsProgram
@@ -26,7 +27,7 @@ class JsAstHandler(testServices: TestServices) : JsBinaryArtifactHandler(testSer
         val ktFiles = module.files.filter { it.isKtFile }.map { it.originalContent }
         val jsProgram = when (val artifact = info.unwrap()) {
             is BinaryArtifacts.Js.OldJsArtifact -> (artifact.translationResult as TranslationResult.Success).program
-            is BinaryArtifacts.Js.JsIrArtifact -> artifact.compilerResult.outputs?.jsProgram ?: return
+            is BinaryArtifacts.Js.JsIrArtifact -> artifact.compilerResult.outputs[TranslationMode.FULL]?.jsProgram ?: return
             else -> return
         }
         processJsProgram(jsProgram, ktFiles, module.targetBackend!!)

js/js.tests/test/org/jetbrains/kotlin/js/test/handlers/JsBoxRunner.kt

@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.js.test.handlers
 
+import org.jetbrains.kotlin.ir.backend.js.transformers.irToJs.TranslationMode
 import org.jetbrains.kotlin.js.testOld.engines.ExternalTool
 import org.jetbrains.kotlin.js.test.utils.*
 import org.jetbrains.kotlin.test.directives.JsEnvironmentConfigurationDirectives
@@ -34,22 +35,16 @@ class JsBoxRunner(testServices: TestServices) : AbstractJsArtifactsCollector(tes
 
         if (dontRunGeneratedCode) return
 
-        val (allJsFiles, dceAllJsFiles) = getAllFilesForRunner(testServices, modulesToArtifact)
+        val allJsFiles = getAllFilesForRunner(testServices, modulesToArtifact)
 
         val withModuleSystem = testWithModuleSystem(testServices)
         val testModuleName = getTestModuleName(testServices)
         val testPackage = extractTestPackage(testServices)
 
         val dontSkipRegularMode = JsEnvironmentConfigurationDirectives.SKIP_REGULAR_MODE !in globalDirectives
-        val dontSkipIrIc = JsEnvironmentConfigurationDirectives.SKIP_IR_INCREMENTAL_CHECKS !in globalDirectives
-        val recompile = testServices.moduleStructure.modules
-            .flatMap { it.files }.any { JsEnvironmentConfigurationDirectives.RECOMPILE in it.directives }
-        val runIrDce = JsEnvironmentConfigurationDirectives.RUN_IR_DCE in globalDirectives
         if (dontSkipRegularMode) {
-            runGeneratedCode(allJsFiles, testModuleName, testPackage, withModuleSystem)
+            for (jsFiles in allJsFiles.values) {
-
+                runGeneratedCode(jsFiles, testModuleName, testPackage, withModuleSystem)
-            if (runIrDce && !(dontSkipIrIc && recompile)) {
-                runGeneratedCode(dceAllJsFiles, testModuleName, testPackage, withModuleSystem)
             }
         }
     }
@@ -58,7 +53,7 @@ class JsBoxRunner(testServices: TestServices) : AbstractJsArtifactsCollector(tes
         val globalDirectives = testServices.moduleStructure.allDirectives
 
         val esmOutputDir = JsEnvironmentConfigurator.getJsArtifactsOutputDir(testServices).esModulesSubDir
-        val esmDceOutputDir = JsEnvironmentConfigurator.getDceJsArtifactsOutputDir(testServices).esModulesSubDir
+        val esmDceOutputDir = JsEnvironmentConfigurator.getJsArtifactsOutputDir(testServices, TranslationMode.FULL_DCE).esModulesSubDir
 
         val dontSkipRegularMode = JsEnvironmentConfigurationDirectives.SKIP_REGULAR_MODE !in globalDirectives
         val runIrDce = JsEnvironmentConfigurationDirectives.RUN_IR_DCE in globalDirectives

js/js.tests/test/org/jetbrains/kotlin/js/test/handlers/JsIrRecompiledArtifactsIdentityHandler.kt

@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.js.test.handlers
 
 import com.intellij.openapi.util.io.FileUtil
 import org.jetbrains.kotlin.fir.backend.FirMetadataSource
+import org.jetbrains.kotlin.ir.backend.js.transformers.irToJs.TranslationMode
 import org.jetbrains.kotlin.js.test.converters.ClassicJsBackendFacade
 import org.jetbrains.kotlin.js.test.converters.augmentWithModuleName
 import org.jetbrains.kotlin.test.backend.handlers.JsBinaryArtifactHandler
@@ -71,7 +72,7 @@ class JsIrRecompiledArtifactsIdentityHandler(testServices: TestServices) : JsBin
 }
 
 private fun Js.JsIrArtifact.allFiles(): Collection<File> {
-    return listOf(outputFile) + compilerResult.outputs!!.dependencies.map { (moduleId, _) ->
+    return listOf(outputFile) + compilerResult.outputs[TranslationMode.FULL]!!.dependencies.map { (moduleId, _) ->
         outputFile.augmentWithModuleName(moduleId)
     }.sortedBy { it.name }
 }

js/js.tests/test/org/jetbrains/kotlin/js/test/utils/RunnerUtils.kt

@@ -5,14 +5,17 @@
 
 package org.jetbrains.kotlin.js.test.utils
 
+import org.jetbrains.kotlin.ir.backend.js.transformers.irToJs.TranslationMode
 import org.jetbrains.kotlin.js.JavaScript
 import org.jetbrains.kotlin.js.config.JSConfigurationKeys
 import org.jetbrains.kotlin.js.test.JsAdditionalSourceProvider
+import org.jetbrains.kotlin.js.test.converters.augmentWithModuleName
 import org.jetbrains.kotlin.js.test.handlers.JsBoxRunner.Companion.TEST_FUNCTION
 import org.jetbrains.kotlin.js.testOld.*
 import org.jetbrains.kotlin.psi.KtNamedFunction
 import org.jetbrains.kotlin.serialization.js.ModuleKind
 import org.jetbrains.kotlin.test.TargetBackend
+import org.jetbrains.kotlin.test.directives.JsEnvironmentConfigurationDirectives
 import org.jetbrains.kotlin.test.directives.JsEnvironmentConfigurationDirectives.NO_JS_MODULE_SYSTEM
 import org.jetbrains.kotlin.test.directives.JsEnvironmentConfigurationDirectives.RUN_PLAIN_BOX_FUNCTION
 import org.jetbrains.kotlin.test.model.BinaryArtifacts
@@ -96,30 +99,53 @@ fun testWithModuleSystem(testServices: TestServices): Boolean {
 
 fun getAllFilesForRunner(
     testServices: TestServices, modulesToArtifact: Map<TestModule, BinaryArtifacts.Js>
-): Pair<List<String>, List<String>> {
+): Map<TranslationMode, List<String>> {
     val originalFile = testServices.moduleStructure.originalTestDataFiles.first()
-    val outputDir = JsEnvironmentConfigurator.getJsArtifactsOutputDir(testServices)
-    val dceOutputDir = JsEnvironmentConfigurator.getDceJsArtifactsOutputDir(testServices)
 
     val commonFiles = JsAdditionalSourceProvider.getAdditionalJsFiles(originalFile.parent).map { it.absolutePath }
     val (inputJsFilesBefore, inputJsFilesAfter) = extractJsFiles(testServices, testServices.moduleStructure.modules)
     val additionalFiles = getAdditionalFiles(testServices)
     val additionalMainFiles = getAdditionalMainFiles(testServices)
 
-    val artifactsPaths = modulesToArtifact.values.map { it.outputFile.absolutePath }.filter { !File(it).isDirectory }
+    if (modulesToArtifact.values.any { it is BinaryArtifacts.Js.JsIrArtifact }) {
-    val klibDependencies = modulesToArtifact.values
+        // JS IR
-        .filterIsInstance<BinaryArtifacts.Js.JsIrArtifact>()
+        val (module, compilerResult) = modulesToArtifact.entries.mapNotNull { (m, c) -> (c as? BinaryArtifacts.Js.JsIrArtifact)?.let { m to c.compilerResult } }.single()
-        .singleOrNull()?.let { artifact ->
+
-            artifact.compilerResult.outputs?.dependencies?.map { (moduleId, _) ->
+        val result = mutableMapOf<TranslationMode, List<String>>()
-                artifact.outputFile.absolutePath.replace("_v5.js", "-${moduleId}_v5.js")
+
+        compilerResult.outputs.entries.forEach { (mode, outputs) ->
+            val paths = mutableListOf<String>()
+
+            val outputFile = JsEnvironmentConfigurator.getJsModuleArtifactPath(testServices, module.name, mode) + ".js"
+            outputs.dependencies.forEach { (moduleId, _) ->
+                paths += outputFile.augmentWithModuleName(moduleId)
             }
-        } ?: emptyList()
+            paths += outputFile
-    val dceJsFiles = (klibDependencies + artifactsPaths).map { it.replace(outputDir.absolutePath, dceOutputDir.absolutePath) }
 
-    val allJsFiles = additionalFiles + inputJsFilesBefore + klibDependencies + artifactsPaths + commonFiles + additionalMainFiles + inputJsFilesAfter
+            result[mode] = additionalFiles + inputJsFilesBefore + paths + commonFiles + additionalMainFiles + inputJsFilesAfter
-    val dceAllJsFiles = additionalFiles + inputJsFilesBefore + dceJsFiles + commonFiles + additionalMainFiles + inputJsFilesAfter
+        }
 
-    return Pair(allJsFiles, dceAllJsFiles)
+        return result
+    } else {
+        // Old BE and ES modules
+        val outputDir = JsEnvironmentConfigurator.getJsArtifactsOutputDir(testServices)
+        val dceOutputDir = JsEnvironmentConfigurator.getJsArtifactsOutputDir(testServices, TranslationMode.FULL_DCE)
+
+        val artifactsPaths = modulesToArtifact.values.map { it.outputFile.absolutePath }.filter { !File(it).isDirectory }
+        val allJsFiles = additionalFiles + inputJsFilesBefore + artifactsPaths + commonFiles + additionalMainFiles + inputJsFilesAfter
+
+        val result = mutableMapOf(TranslationMode.FULL to allJsFiles)
+
+        val globalDirectives = testServices.moduleStructure.allDirectives
+        val runIrDce = JsEnvironmentConfigurationDirectives.RUN_IR_DCE in globalDirectives
+        if (runIrDce) {
+            val dceJsFiles = artifactsPaths.map { it.replace(outputDir.absolutePath, dceOutputDir.absolutePath) }
+            val dceAllJsFiles = additionalFiles + inputJsFilesBefore + dceJsFiles + commonFiles + additionalMainFiles + inputJsFilesAfter
+            result[TranslationMode.FULL_DCE] = dceAllJsFiles
+        }
+
+        return result
+    }
 }
 
 fun extractAllFilesForEsRunner(testServices: TestServices, esmOutputDir: File): Pair<List<String>, List<String>> {
@@ -155,7 +181,9 @@ fun extractAllFilesForEsRunner(testServices: TestServices, esmOutputDir: File):
 }
 
 fun getOnlyJsFilesForRunner(testServices: TestServices, modulesToArtifact: Map<TestModule, BinaryArtifacts.Js>): List<String> {
-    return getAllFilesForRunner(testServices, modulesToArtifact).first
+    return getAllFilesForRunner(testServices, modulesToArtifact).let {
+        it[TranslationMode.FULL] ?: it[TranslationMode.PER_MODULE]!!
+    }
 }
 
 fun getTestModuleName(testServices: TestServices): String? {

js/js.translator/testData/box/export/defaultInlineClassConstructorParam.kt

@@ -1,6 +1,7 @@
 // KT-49225
 // RUN_PLAIN_BOX_FUNCTION
 // IGNORE_BACKEND: JS
+// SPLIT_PER_MODULE
 
 // MODULE: lib
 // FILE: lib.kt

js/js.translator/testData/box/inline/callableReference.kt

@@ -3,9 +3,6 @@ package foo
 
 // CHECK_CONTAINS_NO_CALLS: multiplyInline except=imul TARGET_BACKENDS=JS
 
-// FIXME: Not inlined on IR BE
-// CHECK_CONTAINS_NO_CALLS: multiplyInline except=multiply IGNORED_BACKENDS=JS
-
 // CHECK_FUNCTION_EXISTS: runNoinline
 // CHECK_NOT_CALLED: runNoinline
 

js/js.translator/testData/box/inlineMultiFile/trait.kt

@@ -9,8 +9,6 @@ package foo
 
 import test.*
 
-// CHECK_CONTAINS_NO_CALLS: testClassObject except=Companion_getInstance
-
 internal fun testFinalInline(): String {
     return Z().finalInline({"final"})
 }

js/js.translator/testData/box/jsModule/importCountUmd.kt

@@ -1,7 +1,7 @@
 // EXPECTED_REACHABLE_NODES: 1285
 // MODULE_KIND: UMD
 // NO_JS_MODULE_SYSTEM
-// FUNCTION_CALLED_TIMES: require count=3
+// FUNCTION_CALLED_TIMES: require count=3 TARGET_BACKENDS=JS
 
 @JsModule("lib")
 @JsNonModule