[JS IR] IC improvements

- Reuse a built fragment
  - Use cache for saving built JS code

js/js.tests/build.gradle.kts

@@ -366,6 +366,7 @@ projectTest("wasmTest", true) {
 }
 
 projectTest("invalidationTest", jUnitMode = JUnitMode.JUnit4) {
+    setupV8()
     workingDir = rootDir
 
     include("org/jetbrains/kotlin/incremental/*")

js/js.tests/test/org/jetbrains/kotlin/incremental/AbstractInvalidationTest.kt

@@ -16,25 +16,37 @@ import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.codegen.*
 import org.jetbrains.kotlin.config.CommonConfigurationKeys
 import org.jetbrains.kotlin.config.CompilerConfiguration
-import org.jetbrains.kotlin.ir.backend.js.WholeWorldStageController
-import org.jetbrains.kotlin.ir.backend.js.generateKLib
+import org.jetbrains.kotlin.ir.backend.js.*
 import org.jetbrains.kotlin.ir.backend.js.ic.*
 import org.jetbrains.kotlin.ir.backend.js.lower.serialization.ir.JsIrLinker
-import org.jetbrains.kotlin.ir.backend.js.prepareAnalyzedSourceModule
-import org.jetbrains.kotlin.ir.declarations.IrFactory
+import org.jetbrains.kotlin.ir.backend.js.transformers.irToJs.SourceMapsInfo
+import org.jetbrains.kotlin.ir.backend.js.transformers.irToJs.safeModuleName
 import org.jetbrains.kotlin.ir.declarations.IrModuleFragment
 import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImpl
 import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImplForJsIC
+import org.jetbrains.kotlin.js.config.JSConfigurationKeys
+import org.jetbrains.kotlin.js.testOld.V8IrJsTestChecker
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.serialization.js.ModuleKind
 import org.jetbrains.kotlin.test.KotlinTestWithEnvironment
 import org.jetbrains.kotlin.test.util.JUnit4Assertions
+import org.junit.ComparisonFailure
 import java.io.File
 import kotlin.io.path.createTempDirectory
 
-private var stdlibCacheDir: File? = null
-
 abstract class AbstractInvalidationTest : KotlinTestWithEnvironment() {
+    companion object {
+        private const val TEST_DATA_DIR_PATH = "js/js.translator/testData/"
+
+        private const val stdlibAlias = "stdlib"
+        private const val stdlibModuleName = "kotlin"
+        private val stdlibKlibPath = File(System.getProperty("kotlin.js.stdlib.klib.path") ?: error("Please set stdlib path")).canonicalPath
+        private var stdlibCacheDir: File? = null
+
+        private const val boxFunctionName = "box"
+    }
+
     override fun createEnvironment(): KotlinCoreEnvironment {
         return KotlinCoreEnvironment.createForTests(TestDisposable(), CompilerConfiguration(), EnvironmentConfigFiles.JS_CONFIG_FILES)
     }
@@ -47,36 +59,24 @@ abstract class AbstractInvalidationTest : KotlinTestWithEnvironment() {
         return ModuleInfoParser(infoFile).parse(moduleName)
     }
 
-    @Suppress("UNUSED_PARAMETER")
-    private fun emptyChecker(
-        currentModule: IrModuleFragment,
-        dependencies: Collection<IrModuleFragment>,
-        deserializer: JsIrLinker,
-        configuration: CompilerConfiguration,
-        dirtyFiles: Collection<String>?, // if null consider the whole module dirty
-        artifactCache: ArtifactCache,
-        exportedDeclarations: Set<FqName>,
-        mainArguments: List<String>?,
-    ) {
-    }
-
     private fun initializeStdlibCache() {
         if (stdlibCacheDir != null) return
         val cacheDir = createTempDirectory().toFile()
         cacheDir.deleteOnExit()
 
-        val configuration = createConfiguration("stdlib")
-
-        actualizeCacheForModuleWithPrepare(
+        val cacheUpdater = CacheUpdater(
             stdlibKlibPath,
-            cacheDir.canonicalPath,
-            configuration,
             listOf(stdlibKlibPath),
-            emptyList(),
-            IrFactoryImpl,
-            null, // TODO: mainArguments
-            ::emptyChecker
+            createConfiguration(stdlibAlias),
+            listOf(cacheDir.canonicalPath),
+            { IrFactoryImplForJsIC(WholeWorldStageController()) },
+            null,
+            ::buildCacheForModuleFiles
         )
+        cacheUpdater.actualizeCaches { updateStatus, updatedModule ->
+            JUnit4Assertions.assertEquals(stdlibKlibPath, updatedModule) { "incorrect std klib path" }
+            JUnit4Assertions.assertTrue(updateStatus is CacheUpdateStatus.Dirty) { "std klib should be rebuilt" }
+        }
 
         stdlibCacheDir = cacheDir
     }
@@ -104,70 +104,213 @@ abstract class AbstractInvalidationTest : KotlinTestWithEnvironment() {
 
         initializeWorkingDir(projectInfo, testDirectory, sourceDir, buildDir)
 
-        executeProjectSteps(projectInfo, modulesInfos, testDirectory, sourceDir, buildDir)
+        ProjectStepsExecutor(projectInfo, modulesInfos, testDirectory, sourceDir, buildDir).execute()
     }
 
-    private val stdlibKlibPath = System.getProperty("kotlin.js.stdlib.klib.path") ?: error("Please set stdlib path")
-
-    private val String.artifactName: String get() = "$this.klib"
-
     private fun resolveModuleArtifact(moduleName: String, buildDir: File): File {
-        if (moduleName == "stdlib") return File(stdlibKlibPath)
-        return File(File(buildDir, moduleName), moduleName.artifactName)
+        if (moduleName == stdlibAlias) return File(stdlibKlibPath)
+        return File(File(buildDir, moduleName), "$moduleName.klib")
     }
 
     private fun resolveModuleCache(moduleName: String, buildDir: File): File {
-        if (moduleName == "stdlib") return stdlibCacheDir ?: error("stdlib cache corruption")
+        if (moduleName == stdlibAlias) return stdlibCacheDir ?: error("stdlib cache corruption")
         return File(File(buildDir, moduleName), "cache")
     }
 
     private fun createConfiguration(moduleName: String): CompilerConfiguration {
         val copy = environment.configuration.copy()
         copy.put(CommonConfigurationKeys.MODULE_NAME, moduleName)
+        copy.put(JSConfigurationKeys.MODULE_KIND, ModuleKind.PLAIN)
         return copy
     }
 
-    private fun executeProjectSteps(
-        projectInfo: ProjectInfo,
-        moduleInfos: Map<String, ModuleInfo>,
-        testDir: File,
-        sourceDir: File,
-        buildDir: File
+    private inner class ProjectStepsExecutor(
+        private val projectInfo: ProjectInfo,
+        private val moduleInfos: Map<String, ModuleInfo>,
+        private val testDir: File,
+        private val sourceDir: File,
+        private val buildDir: File
     ) {
-        for (projStep in projectInfo.steps) {
-            for (module in projStep.order) {
-                val moduleTestDir = File(testDir, module)
-                val moduleSourceDir = File(sourceDir, module)
-                val moduleInfo = moduleInfos[module] ?: error("No module info found for $module")
-                val moduleStep = moduleInfo.steps[projStep.id]
-                val deletedFiles = mutableListOf<File>()
-                for (modification in moduleStep.modifications) {
-                    modification.execute(moduleTestDir, moduleSourceDir) { deletedFiles.add(it) }
+        private inner class TestStepInfo(
+            val moduleName: String,
+            val modulePath: String,
+            val icCacheDir: String,
+            val directives: Set<StepDirectives>,
+            val dirtyFiles: List<String> = emptyList(),
+            val deletedFiles: List<String> = emptyList()
+        )
+
+        private fun setupTestStep(projStepId: Int, module: String): TestStepInfo {
+            val moduleTestDir = File(testDir, module)
+            val moduleSourceDir = File(sourceDir, module)
+            val moduleInfo = moduleInfos[module] ?: error("No module info found for $module")
+            val moduleStep = moduleInfo.steps[projStepId]
+            val deletedFiles = mutableListOf<File>()
+            for (modification in moduleStep.modifications) {
+                modification.execute(moduleTestDir, moduleSourceDir) { deletedFiles.add(it) }
+            }
+
+            val dependencies = moduleStep.dependencies.map { resolveModuleArtifact(it, buildDir) }
+            val outputKlibFile = resolveModuleArtifact(module, buildDir)
+            val configuration = createConfiguration(module)
+            buildArtifact(configuration, module, moduleSourceDir, dependencies, outputKlibFile)
+
+            return TestStepInfo(
+                module.safeModuleName,
+                outputKlibFile.canonicalPath,
+                resolveModuleCache(module, buildDir).canonicalPath,
+                moduleStep.directives,
+                moduleStep.dirtyFiles.map { File(moduleSourceDir, it).canonicalPath },
+                deletedFiles.map { it.canonicalPath }
+            )
+        }
+
+        private fun verifyCacheUpdateStatus(stepId: Int, statuses: Map<String, CacheUpdateStatus>, testInfo: List<TestStepInfo>) {
+            val expectedInfo = testInfo.filter { StepDirectives.UNUSED_MODULE !in it.directives }
+
+            JUnit4Assertions.assertEquals(statuses.size, expectedInfo.size) {
+                "Mismatched updated modules count at step $stepId"
+            }
+
+            for (info in expectedInfo) {
+                JUnit4Assertions.assertTrue(info.modulePath in statuses) {
+                    "Status is missed for ${info.modulePath} at step $stepId"
+                }
+                val updateStatus = statuses[info.modulePath]!!
+                if (StepDirectives.FAST_PATH_UPDATE in info.directives) {
+                    JUnit4Assertions.assertEquals(CacheUpdateStatus.FastPath, updateStatus) {
+                        "Cache has to be checked by fast path, instead it $updateStatus at step $stepId"
+                    }
+                } else {
+                    JUnit4Assertions.assertNotEquals(CacheUpdateStatus.FastPath, updateStatus) {
+                        "Cache has not to be checked by fast path, but it is at step $stepId"
+                    }
                 }
 
-                val dependencies = moduleStep.dependencies.map { resolveModuleArtifact(it, buildDir) }
+                val (updated, removed) = when (updateStatus) {
+                    is CacheUpdateStatus.FastPath -> emptySet<String>() to emptySet()
+                    is CacheUpdateStatus.NoDirtyFiles -> emptySet<String>() to updateStatus.removed
+                    is CacheUpdateStatus.Dirty -> updateStatus.updated to updateStatus.removed
+                }
 
-                val outputKlibFile = resolveModuleArtifact(module, buildDir)
+                JUnit4Assertions.assertSameElements(info.dirtyFiles, updated.map { File(it).canonicalPath }) {
+                    "Mismatched DIRTY files for module ${info.moduleName} at step $stepId"
+                }
 
-                val configuration = createConfiguration(module)
+                JUnit4Assertions.assertSameElements(info.deletedFiles, removed.map { File(it).canonicalPath }) {
+                    "Mismatched DELETED files for module ${info.moduleName} at step $stepId"
+                }
+            }
+        }
 
-                buildArtifact(configuration, module, moduleSourceDir, dependencies, outputKlibFile)
+        private fun verifyJsExecutableProducerBuildModules(stepId: Int, gotRebuilt: Set<String>, expectedRebuilt: List<String>) {
+            val expected = expectedRebuilt.map { if (it == stdlibAlias) stdlibModuleName.safeModuleName else it.safeModuleName }
+            JUnit4Assertions.assertSameElements(expected, gotRebuilt) {
+                "Mismatched rebuilt modules at step $stepId"
+            }
+        }
 
-                val dirtyFiles = moduleStep.dirtyFiles.map { File(moduleSourceDir, it) }
-                val icCaches = moduleStep.dependencies.map { resolveModuleCache(it, buildDir) }
+        fun writeJsFile(name: String, text: String): String {
+            val file = File(buildDir, "$name.js")
+            if (file.exists()) {
+                file.delete()
+            }
+            file.writeText(text)
+            return file.canonicalPath
+        }
 
-                val moduleCacheDir = resolveModuleCache(module, buildDir)
-
-                buildCachesAndCheck(
-                    moduleStep,
-                    configuration,
-                    outputKlibFile,
-                    moduleCacheDir,
-                    dependencies,
-                    icCaches,
-                    dirtyFiles,
-                    deletedFiles
+        private fun verifyJsCode(stepId: Int, mainModuleName: String, jsOutput: CompilationOutputs) {
+            val files = jsOutput.dependencies.map { writeJsFile(it.first, it.second.jsCode) } + writeJsFile(mainModuleName, jsOutput.jsCode)
+            try {
+                V8IrJsTestChecker.checkWithTestFunctionArgs(
+                    files = files,
+                    testModuleName = mainModuleName,
+                    testPackageName = null,
+                    testFunctionName = boxFunctionName,
+                    testFunctionArgs = "$stepId",
+                    expectedResult = "OK",
+                    withModuleSystem = false
                 )
+            } catch (e: ComparisonFailure) {
+                throw ComparisonFailure("Mismatched box out at step $stepId", e.expected, e.actual)
+            } catch (e: IllegalStateException) {
+                throw IllegalStateException("Something goes wrong (bad JS code?) at step $stepId\n${e.message}")
+            }
+        }
+
+        fun executorWithBoxExport(
+            currentModule: IrModuleFragment,
+            dependencies: Collection<IrModuleFragment>,
+            deserializer: JsIrLinker,
+            configuration: CompilerConfiguration,
+            dirtyFiles: Collection<String>?,
+            artifactCache: ArtifactCache,
+            exportedDeclarations: Set<FqName>,
+            mainArguments: List<String>?
+        ) {
+            buildCacheForModuleFiles(
+                currentModule = currentModule,
+                dependencies = dependencies,
+                deserializer = deserializer,
+                configuration = configuration,
+                dirtyFiles = dirtyFiles,
+                artifactCache = artifactCache,
+                exportedDeclarations = exportedDeclarations + FqName(boxFunctionName),
+                mainArguments = mainArguments,
+            )
+        }
+
+        fun execute() {
+            val stdlibInfo = TestStepInfo(
+                moduleName = stdlibModuleName.safeModuleName,
+                modulePath = stdlibKlibPath,
+                icCacheDir = stdlibCacheDir!!.canonicalPath,
+                directives = setOf(StepDirectives.FAST_PATH_UPDATE)
+            )
+            for (projStep in projectInfo.steps) {
+                val testInfo = projStep.order.mapTo(mutableListOf(stdlibInfo)) { setupTestStep(projStep.id, it) }
+
+                val configuration = createConfiguration(projStep.order.last())
+                val cacheUpdater = CacheUpdater(
+                    rootModule = testInfo.last().modulePath,
+                    testInfo.map { it.modulePath },
+                    configuration,
+                    testInfo.map { it.icCacheDir },
+                    { IrFactoryImplForJsIC(WholeWorldStageController()) },
+                    null,
+                    ::executorWithBoxExport
+                )
+
+                val updateStatuses = mutableMapOf<String, CacheUpdateStatus>()
+                var icCaches = cacheUpdater.actualizeCaches { updateStatus, updatedModule -> updateStatuses[updatedModule] = updateStatus }
+                verifyCacheUpdateStatus(projStep.id, updateStatuses, testInfo)
+
+                val mainModuleCacheDir = icCaches.last().artifactsDir!!
+                // tests use one stdlib artifact for all cases, patching stdlib cache path here:
+                //  - enable using cached js (stdlib) file through all steps in a test case
+                //  - disable using cached js (stdlib) file through test cases
+                icCaches = icCaches.map {
+                    when (it.moduleSafeName) {
+                        stdlibModuleName.safeModuleName -> {
+                            val stdlibDir = File(mainModuleCacheDir, stdlibAlias).apply { mkdirs() }
+                            ModuleArtifact(stdlibModuleName, it.fileArtifacts, stdlibDir, it.forceRebuildJs)
+                        }
+                        else -> it
+                    }
+                }
+
+                val jsExecutableProducer = JsExecutableProducer(
+                    mainModuleName = testInfo.last().moduleName,
+                    moduleKind = configuration[JSConfigurationKeys.MODULE_KIND]!!,
+                    sourceMapsInfo = SourceMapsInfo.from(configuration),
+                    caches = icCaches,
+                    relativeRequirePath = true
+                )
+
+                val rebuiltModules = mutableSetOf<String>()
+                val jsOutput = jsExecutableProducer.buildExecutable(true) { rebuiltModules += it }
+                verifyJsExecutableProducerBuildModules(projStep.id, rebuiltModules, projStep.dirtyJS)
+                verifyJsCode(projStep.id, testInfo.last().moduleName, jsOutput)
             }
         }
     }
@@ -177,83 +320,6 @@ abstract class AbstractInvalidationTest : KotlinTestWithEnvironment() {
         return listFiles { _, name -> name.endsWith(".kt") }!!.toList()
     }
 
-    private fun buildCachesAndCheck(
-        moduleStep: ModuleInfo.ModuleStep,
-        configuration: CompilerConfiguration,
-        moduleKlibFile: File,
-        moduleCacheDir: File,
-        dependencies: List<File>,
-        icCaches: List<File>,
-        expectedDirtyFiles: List<File>,
-        expectedDeletedFiles: List<File>
-    ) {
-        val dependenciesPaths = mutableListOf<String>()
-        dependencies.mapTo(dependenciesPaths) { it.canonicalPath }
-        dependenciesPaths.add(moduleKlibFile.canonicalPath)
-
-        val updateStatus = actualizeCacheForModuleWithPrepare(
-            moduleKlibFile.canonicalPath,
-            moduleCacheDir.canonicalPath,
-            configuration,
-            dependenciesPaths,
-            icCaches.map { it.canonicalPath },// + moduleCacheDir.canonicalPath,
-            IrFactoryImpl,
-            null, // TODO: mainArguments
-            ::emptyChecker
-        )
-
-        if (StepDirectives.FAST_PATH_UPDATE in moduleStep.directives) {
-            JUnit4Assertions.assertEquals(CacheUpdateStatus.FastPath, updateStatus) {
-                "Cache has to be checked by fast path, instead it $updateStatus"
-            }
-        }
-
-        val (updated, removed) = when (updateStatus) {
-            is CacheUpdateStatus.FastPath -> emptySet<String>() to emptySet<String>()
-            is CacheUpdateStatus.NoDirtyFiles -> emptySet<String>() to updateStatus.removed
-            is CacheUpdateStatus.Dirty -> updateStatus.updated to updateStatus.removed
-        }
-
-        val actualDirtyFiles = updated.map { File(it).canonicalPath }
-        val expectedDirtyFilesCanonical = expectedDirtyFiles.map { it.canonicalPath }
-        JUnit4Assertions.assertSameElements(expectedDirtyFilesCanonical, actualDirtyFiles) {
-            "Mismatched DIRTY files for module $moduleKlibFile at step ${moduleStep.id}"
-        }
-
-        val actualDeletedFiles = removed.map { File(it).canonicalPath }
-        val expectedDeletedFilesCanonical = expectedDeletedFiles.map { it.canonicalPath }
-        JUnit4Assertions.assertSameElements(expectedDeletedFilesCanonical, actualDeletedFiles) {
-            "Mismatched DELETED files for module $moduleKlibFile at step ${moduleStep.id}"
-        }
-    }
-
-    private fun actualizeCacheForModuleWithPrepare(
-        moduleName: String,
-        cachePath: String,
-        compilerConfiguration: CompilerConfiguration,
-        dependencies: Collection<String>,
-        icCachePaths: Collection<String>,
-        irFactory: IrFactory,
-        mainArguments: List<String>?,
-        executor: CacheExecutor
-    ): CacheUpdateStatus {
-        val modulePath = File(moduleName).canonicalPath
-        val statuses = mutableMapOf<String, CacheUpdateStatus>()
-        val cacheUpdater = CacheUpdater(
-            modulePath,
-            dependencies,
-            compilerConfiguration,
-            icCachePaths + cachePath,
-            { irFactory },
-            mainArguments,
-            executor
-        )
-        cacheUpdater.actualizeCaches { updateStatus, updatedModule ->
-            statuses[updatedModule] = updateStatus
-        }
-        return statuses[modulePath] ?: error("Status is missed for $modulePath")
-    }
-
     private fun KotlinCoreEnvironment.createPsiFile(file: File): KtFile {
         val psiManager = PsiManager.getInstance(project)
         val fileSystem = VirtualFileManager.getInstance().getFileSystem(StandardFileSystems.FILE_PROTOCOL) as CoreLocalFileSystem
@@ -317,9 +383,4 @@ abstract class AbstractInvalidationTest : KotlinTestWithEnvironment() {
 
         return dir
     }
-
-    companion object {
-        const val TEST_DATA_DIR_PATH = "js/js.translator/testData/"
-    }
-
 }

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

@@ -17,6 +17,7 @@ import org.jetbrains.kotlin.ir.backend.js.codegen.JsGenerationGranularity
 import org.jetbrains.kotlin.ir.backend.js.codegen.JsGenerationOptions
 import org.jetbrains.kotlin.ir.backend.js.codegen.generateEsModules
 import org.jetbrains.kotlin.ir.backend.js.dce.eliminateDeadDeclarations
+import org.jetbrains.kotlin.ir.backend.js.ic.JsExecutableProducer
 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
@@ -98,11 +99,20 @@ class JsIrBackendFacade(
             } else {
                 File(JsEnvironmentConfigurator.getRecompiledJsModuleArtifactPath(testServices, module.name) + ".js")
             }
-            val moduleName = configuration.getNotNull(CommonConfigurationKeys.MODULE_NAME)
-            val moduleKind = configuration.get(JSConfigurationKeys.MODULE_KIND, ModuleKind.PLAIN)
-            val sourceMapsInfo = SourceMapsInfo.from(configuration)
-            val translationModes = setOf(TranslationMode.FULL, TranslationMode.PER_MODULE)
-            val compiledModule = generateJsFromAst(moduleName, moduleKind, sourceMapsInfo, translationModes, testServices.jsIrIncrementalDataProvider.getCaches())
+
+            val compiledModule = CompilerResult(
+                outputs = listOf(TranslationMode.FULL, TranslationMode.PER_MODULE).associateWith {
+                    val jsExecutableProducer = JsExecutableProducer(
+                        mainModuleName = configuration.getNotNull(CommonConfigurationKeys.MODULE_NAME),
+                        moduleKind = configuration.get(JSConfigurationKeys.MODULE_KIND, ModuleKind.PLAIN),
+                        sourceMapsInfo = SourceMapsInfo.from(configuration),
+                        caches = testServices.jsIrIncrementalDataProvider.getCaches(),
+                        relativeRequirePath = false
+                    )
+                    jsExecutableProducer.buildExecutable(it.perModule)
+                },
+                tsDefinitions = null
+            )
             return BinaryArtifacts.Js.JsIrArtifact(
                 outputFile, compiledModule, testServices.jsIrIncrementalDataProvider.getCacheForModule(module)
             ).dump(module, firstTimeCompilation)

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

@@ -9,6 +9,7 @@ import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.ir.backend.js.WholeWorldStageController
 import org.jetbrains.kotlin.ir.backend.js.ic.*
 import org.jetbrains.kotlin.ir.backend.js.moduleName
+import org.jetbrains.kotlin.ir.backend.js.utils.serialization.JsIrAstDeserializer
 import org.jetbrains.kotlin.ir.declarations.impl.IrFactoryImplForJsIC
 import org.jetbrains.kotlin.js.test.handlers.JsBoxRunner
 import org.jetbrains.kotlin.konan.properties.propertyList
@@ -22,17 +23,31 @@ import org.jetbrains.kotlin.test.services.TestServices
 import org.jetbrains.kotlin.test.services.compilerConfigurationProvider
 import org.jetbrains.kotlin.test.services.configuration.JsEnvironmentConfigurator
 import org.jetbrains.kotlin.test.services.jsLibraryProvider
+import java.io.ByteArrayInputStream
 import java.io.File
 
 private class TestArtifactCache(var moduleName: String? = null) : ArtifactCache() {
-    override fun fetchArtifacts() = KLibArtifact(
-        moduleName = moduleName ?: error("Module name is not set"),
-        fileArtifacts = binaryAsts.entries.map {
-            SrcFileArtifact(it.key, "", it.value)
-        }
-    )
+    override fun fetchArtifacts(): ModuleArtifact {
+        val deserializer = JsIrAstDeserializer()
+        return ModuleArtifact(
+            moduleName = moduleName ?: error("Module name is not set"),
+            fileArtifacts = binaryAsts.entries.map {
+                SrcFileArtifact(
+                    srcFilePath = it.key,
+                    // TODO: It will be better to use saved fragments (this.fragments), but it doesn't work
+                    //  Merger.merge() + JsNode.resolveTemporaryNames() modify fragments,
+                    //  therefore the sequential calls produce different results
+                    fragment = deserializer.deserialize(ByteArrayInputStream(it.value))
+                )
+            }
+        )
+    }
+
+    fun invalidateForFile(srcPath: String) {
+        binaryAsts.remove(srcPath)
+        fragments.remove(srcPath)
+    }
 
-    fun invalidateForFile(srcPath: String) = binaryAsts.remove(srcPath)
     fun getAst(srcPath: String) = binaryAsts[srcPath]
 }
 

js/js.tests/test/org/jetbrains/kotlin/js/testOld/JsTestChecker.kt

@@ -26,7 +26,8 @@ fun ScriptEngine.runTestFunction(
     testModuleName: String?,
     testPackageName: String?,
     testFunctionName: String,
-    withModuleSystem: Boolean
+    withModuleSystem: Boolean,
+    testFunctionArgs: String = "",
 ): String {
     var script = when {
         withModuleSystem -> "\$kotlin_test_internal\$.require('" + testModuleName!! + "')"
@@ -38,7 +39,7 @@ fun ScriptEngine.runTestFunction(
         script += ".$testPackageName"
     }
 
-    script += ".$testFunctionName()"
+    script += ".$testFunctionName($testFunctionArgs)"
 
     return eval(script)
 }
@@ -52,7 +53,20 @@ abstract class AbstractJsTestChecker {
         expectedResult: String,
         withModuleSystem: Boolean
     ) {
-        val actualResult = run(files, testModuleName, testPackageName, testFunctionName, withModuleSystem)
+        val actualResult = run(files, testModuleName, testPackageName, testFunctionName, "", withModuleSystem)
+        Assert.assertEquals(expectedResult, actualResult.normalize())
+    }
+
+    fun checkWithTestFunctionArgs(
+        files: List<String>,
+        testModuleName: String?,
+        testPackageName: String?,
+        testFunctionName: String,
+        testFunctionArgs: String,
+        expectedResult: String,
+        withModuleSystem: Boolean
+    ) {
+        val actualResult = run(files, testModuleName, testPackageName, testFunctionName, testFunctionArgs, withModuleSystem)
         Assert.assertEquals(expectedResult, actualResult.normalize())
     }
 
@@ -61,9 +75,10 @@ abstract class AbstractJsTestChecker {
         testModuleName: String?,
         testPackageName: String?,
         testFunctionName: String,
+        testFunctionArgs: String,
         withModuleSystem: Boolean
     ) = run(files) {
-        runTestFunction(testModuleName, testPackageName, testFunctionName, withModuleSystem)
+        runTestFunction(testModuleName, testPackageName, testFunctionName, withModuleSystem, testFunctionArgs)
     }
 
 

js/js.tests/tests-gen/org/jetbrains/kotlin/incremental/InvalidationTestGenerated.java

@@ -45,6 +45,11 @@ public class InvalidationTestGenerated extends AbstractInvalidationTest {
         runTest("js/js.translator/testData/incremental/invalidation/constVals/");
     }
 
+    @TestMetadata("crossModuleReferences")
+    public void testCrossModuleReferences() throws Exception {
+        runTest("js/js.translator/testData/incremental/invalidation/crossModuleReferences/");
+    }
+
     @TestMetadata("fastPath1")
     public void testFastPath1() throws Exception {
         runTest("js/js.translator/testData/incremental/invalidation/fastPath1/");

js/js.translator/testData/incremental/invalidation/class/main/m.kt

@@ -1,2 +1,9 @@
 
-fun box() = Demo(100500) == Demo(15)
+fun box(stepId: Int): String {
+    when (stepId) {
+        0, 2 -> if (Demo(15) == Demo(15)) return "Fail"
+        1, 3 -> if (Demo(15) != Demo(15)) return "Fail"
+        else -> return "Unknown"
+    }
+    return "OK"
+}

js/js.translator/testData/incremental/invalidation/class/main/module.info

@@ -1,9 +1,5 @@
 STEP 0:
     dependencies: stdlib, lib1
     dirty: m.kt
-STEP 1:
-    dependencies: stdlib, lib1
-STEP 2:
-    dependencies: stdlib, lib1
-STEP 3:
+STEP 1..3:
     dependencies: stdlib, lib1

js/js.translator/testData/incremental/invalidation/class/project.info

@@ -2,9 +2,7 @@ MODULES: lib1, main
 
 STEP 0:
     libs: lib1, main
-STEP 1:
-    libs: lib1, main
-STEP 2:
-    libs: lib1, main
-STEP 3:
+    dirty js: stdlib, lib1, main
+STEP 1..3:
     libs: lib1, main
+    dirty js: stdlib, lib1

js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/main/m.kt

@@ -1 +1,39 @@
-fun box() = Demo("test1").foo() + Demo("test2").foo_inline() + "${Demo("test3").field1}"
+
+fun isEqual(l: Any?, r: Any?) = if (l == r) true else null
+
+fun box(stepId: Int): String {
+    when (stepId) {
+        0 -> {
+            isEqual(Demo("test1").foo(), "foo test1") ?: return "Fail function"
+            isEqual(Demo("test2").foo_inline(), "inline foo test2") ?: return "Fail inline function"
+            isEqual(Demo("test3").field1, "field1") ?: return "Fail field"
+        }
+        1 -> {
+            isEqual(Demo("test1").foo(), "foo test1 update") ?: return "Fail function"
+            isEqual(Demo("test2").foo_inline(), "inline foo test2") ?: return "Fail inline function"
+            isEqual(Demo("test3").field1, "field1") ?: return "Fail field"
+        }
+        2, 3, 4 -> {
+            isEqual(Demo("test1").foo(), "foo test1 update") ?: return "Fail function"
+            isEqual(Demo("test2").foo_inline(), "inline foo test2 update") ?: return "Fail inline function"
+            isEqual(Demo("test3").field1, "field1") ?: return "Fail field"
+        }
+        5, 6, 7, 8, 9 -> {
+            isEqual(Demo("test1").foo(), "foo test1 update") ?: return "Fail function"
+            isEqual(Demo("test2").foo_inline(), "inline foo test2 update") ?: return "Fail inline function"
+            isEqual(Demo("test3").field1, "field1 update") ?: return "Fail field"
+        }
+        10 -> {
+            isEqual(Demo("test1").foo(), "foo test1 update") ?: return "Fail function"
+            isEqual(Demo("test2").foo_inline(), "inline foo test2 update") ?: return "Fail inline function"
+            isEqual(Demo("test3").field1, 77) ?: return "Fail field"
+        }
+        11 -> {
+            isEqual(Demo("test1").foo(), "foo test1 update") ?: return "Fail function"
+            isEqual(Demo("test2").foo_inline(), "inline foo test2 update") ?: return "Fail inline function"
+            isEqual(Demo("test3").field1, null) ?: return "Fail field"
+        }
+        else -> return "Unkown"
+    }
+    return "OK"
+}

js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/main/module.info

@@ -3,27 +3,11 @@ STEP 0:
     dirty: m.kt
 STEP 1:
     dependencies: stdlib, lib1
-STEP 2:
+STEP 2..3:
     dependencies: stdlib, lib1
     dirty: m.kt
-STEP 3:
-    dependencies: stdlib, lib1
-    dirty: m.kt
-STEP 4:
-    dependencies: stdlib, lib1
-STEP 5:
-    dependencies: stdlib, lib1
-STEP 6:
-    dependencies: stdlib, lib1
-STEP 7:
-    dependencies: stdlib, lib1
-STEP 8:
-    dependencies: stdlib, lib1
-STEP 9:
-    dependencies: stdlib, lib1
-STEP 10:
-    dependencies: stdlib, lib1
-    dirty: m.kt
-STEP 11:
+STEP 4..9:
+    dependencies: stdlib, lib1
+STEP 10..11:
     dependencies: stdlib, lib1
     dirty: m.kt

js/js.translator/testData/incremental/invalidation/classFunctionsAndFields/project.info

@@ -2,25 +2,22 @@ MODULES: lib1, main
 
 STEP 0:
     libs: lib1, main
+    dirty js: stdlib, lib1, main
 STEP 1:
     libs: lib1, main
-STEP 2:
+    dirty js: lib1
+STEP 2..3:
     libs: lib1, main
-STEP 3:
-    libs: lib1, main
-STEP 4:
-    libs: lib1, main
-STEP 5:
-    libs: lib1, main
-STEP 6:
+    dirty js: lib1, main
+STEP 4..6:
     libs: lib1, main
+    dirty js: lib1
 STEP 7:
     libs: lib1, main
-STEP 8:
+    dirty js: stdlib, lib1
+STEP 8..9:
     libs: lib1, main
-STEP 9:
-    libs: lib1, main
-STEP 10:
-    libs: lib1, main
-STEP 11:
+    dirty js: lib1
+STEP 10..11:
     libs: lib1, main
+    dirty js: lib1, main

js/js.translator/testData/incremental/invalidation/constVals/lib2/module.info

@@ -1,6 +1,5 @@
 STEP 0:
     dependencies: stdlib, lib1
     dirty: l2.kt
-
 STEP 1:
     dependencies: stdlib, lib1

js/js.translator/testData/incremental/invalidation/constVals/main/m.kt

@@ -1,2 +1,15 @@
 
-fun box() = qux() == bar()
+fun box(stepId: Int): String {
+    when (stepId) {
+        0 -> {
+            if (qux() != "FOO") return "Fail qux"
+            if (bar() != "FOO") return "Fail bar"
+        }
+        1 -> {
+            if (qux() != "BAR") return "Fail qux"
+            if (bar() != "BAR") return "Fail bar"
+        }
+        else -> return "Unknown"
+    }
+    return "OK"
+}

js/js.translator/testData/incremental/invalidation/constVals/main/module.info

@@ -1,6 +1,5 @@
 STEP 0:
     dependencies: stdlib, lib1, lib2
     dirty: m.kt
-
 STEP 1:
     dependencies: stdlib, lib1, lib2

js/js.translator/testData/incremental/invalidation/constVals/project.info

@@ -2,6 +2,7 @@ MODULES: lib1, lib2, main
 
 STEP 0:
     libs: lib1, lib2, main
-
+    dirty js: stdlib, lib1, lib2, main
 STEP 1:
-    libs: lib1, lib2, main
+    libs: lib1, lib2, main
+    dirty js: lib1

js/js.translator/testData/incremental/invalidation/crossModuleReferences/lib1/l1.kt

@@ -0,0 +1,6 @@
+fun foo() = 42
+fun bar() = 24
+
+fun baz(s: String) = s.length
+fun baz(i: Int) = i + 2
+fun baz(b: Boolean) = if (b) 10 else 1

js/js.translator/testData/incremental/invalidation/crossModuleReferences/lib1/module.info

@@ -0,0 +1,6 @@
+STEP 0:
+    dependencies: stdlib
+    dirty: l1.kt
+STEP 1..6:
+    dependencies: stdlib
+    flags: FP

js/js.translator/testData/incremental/invalidation/crossModuleReferences/lib2/l2.kt

@@ -0,0 +1,2 @@
+
+fun qux() = foo() + 2

js/js.translator/testData/incremental/invalidation/crossModuleReferences/lib2/l2.kt.1.txt

@@ -0,0 +1,2 @@
+
+fun qux() = foo() + bar()

js/js.translator/testData/incremental/invalidation/crossModuleReferences/lib2/l2.kt.2.txt

@@ -0,0 +1,2 @@
+
+fun qux() = foo() - 2

js/js.translator/testData/incremental/invalidation/crossModuleReferences/lib2/l2.kt.3.txt

@@ -0,0 +1,2 @@
+
+fun qux() = baz(2) + baz("test") + baz(true)

js/js.translator/testData/incremental/invalidation/crossModuleReferences/lib2/l2.kt.4.txt

@@ -0,0 +1,2 @@
+
+fun qux() = baz("test") + baz(true)

js/js.translator/testData/incremental/invalidation/crossModuleReferences/lib2/l2.kt.6.txt

@@ -0,0 +1,2 @@
+
+fun qux() = baz("test") + 100

js/js.translator/testData/incremental/invalidation/crossModuleReferences/lib2/module.info

@@ -0,0 +1,31 @@
+STEP 0:
+    dependencies: stdlib, lib1
+    dirty: l2.kt
+STEP 1:
+    dependencies: stdlib, lib1
+    modifications:
+        U : l2.kt.1.txt -> l2.kt
+    dirty: l2.kt
+STEP 2:
+    dependencies: stdlib, lib1
+    modifications:
+        U : l2.kt.2.txt -> l2.kt
+    dirty: l2.kt
+STEP 3:
+    dependencies: stdlib, lib1
+    modifications:
+        U : l2.kt.3.txt -> l2.kt
+    dirty: l2.kt
+STEP 4:
+    dependencies: stdlib, lib1
+    modifications:
+        U : l2.kt.4.txt -> l2.kt
+    dirty: l2.kt
+STEP 5:
+    dependencies: stdlib, lib1
+    flags: FP
+STEP 6:
+    dependencies: stdlib, lib1
+    modifications:
+        U : l2.kt.6.txt -> l2.kt
+    dirty: l2.kt

js/js.translator/testData/incremental/invalidation/crossModuleReferences/main/m.kt

@@ -0,0 +1,12 @@
+
+fun box(stepId: Int): String {
+    when (stepId) {
+        0 -> if (qux() != 44) return "Fail"
+        1 -> if (qux() != 66) return "Fail"
+        2 -> if (qux() != 40) return "Fail"
+        3 -> if (qux() != 18) return "Fail"
+        4 -> if (qux() != 14) return "Fail"
+        else -> return "Unknown"
+    }
+    return "OK"
+}

js/js.translator/testData/incremental/invalidation/crossModuleReferences/main/m.kt.5.txt

@@ -0,0 +1,11 @@
+
+fun box(stepId: Int): String {
+    when (stepId) {
+        5 -> if (qux() != 14) return "Fail"
+        6 -> if (qux() != 104) return "Fail"
+        else -> return "Unknown"
+    }
+    if (baz(77) != 79) return "Fail"
+    if (baz("test") != 4) return "Fail"
+    return "OK"
+}

js/js.translator/testData/incremental/invalidation/crossModuleReferences/main/module.info

@@ -0,0 +1,12 @@
+STEP 0:
+    dependencies: stdlib, lib1, lib2
+    dirty: m.kt
+STEP 1..4:
+    dependencies: stdlib, lib1, lib2
+STEP 5:
+    dependencies: stdlib, lib1, lib2
+    modifications:
+        U : m.kt.5.txt -> m.kt
+    dirty: m.kt
+STEP 6:
+    dependencies: stdlib, lib1, lib2

js/js.translator/testData/incremental/invalidation/crossModuleReferences/project.info

@@ -0,0 +1,14 @@
+MODULES: lib1, lib2, main
+
+STEP 0:
+    libs: lib1, lib2, main
+    dirty js: stdlib, lib1, lib2, main
+STEP 1..4:
+    libs: lib1, lib2, main
+    dirty js: lib1, lib2
+STEP 5:
+    libs: lib1, lib2, main
+    dirty js: lib1, main
+STEP 6:
+    libs: lib1, lib2, main
+    dirty js: lib1, lib2, main

js/js.translator/testData/incremental/invalidation/fastPath1/lib1/module.info

@@ -3,5 +3,4 @@ STEP 0:
     dirty: l1.kt
 STEP 1:
     dependencies: stdlib
-    dirty:
     flags: FP

js/js.translator/testData/incremental/invalidation/fastPath1/lib2/module.info

@@ -1,9 +1,8 @@
 STEP 0:
     dependencies: stdlib, lib1
     dirty: l2.kt
-
 STEP 1:
     dependencies: stdlib, lib1
     modifications:
         U : l2.kt.1 -> l2.kt
-    dirty: l2.kt
+    dirty: l2.kt

js/js.translator/testData/incremental/invalidation/fastPath1/main/m.kt

@@ -1,2 +1,9 @@
 
-fun box() = qux()
+fun box(stepId: Int): String {
+    when (stepId) {
+        0 -> if (qux() != 42) return "Fail"
+        1 -> if (qux() != 44) return "Fail"
+        else -> return "Unknown"
+    }
+    return "OK"
+}

js/js.translator/testData/incremental/invalidation/fastPath1/main/module.info

@@ -1,6 +1,5 @@
 STEP 0:
     dependencies: stdlib, lib1, lib2
     dirty: m.kt
-
 STEP 1:
-    dependencies: stdlib, lib1, lib2
+    dependencies: stdlib, lib1, lib2

js/js.translator/testData/incremental/invalidation/fastPath1/project.info

@@ -2,6 +2,7 @@ MODULES: lib1, lib2, main
 
 STEP 0:
     libs: lib1, lib2, main
-
+    dirty js: stdlib, lib1, lib2, main
 STEP 1:
-    libs: lib1, lib2, main
+    libs: lib1, lib2, main
+    dirty js: lib2

js/js.translator/testData/incremental/invalidation/fastPath2/lib1/module.info

@@ -3,5 +3,4 @@ STEP 0:
     dirty: l1.kt
 STEP 1:
     dependencies: stdlib
-    dirty:
     flags: FP

js/js.translator/testData/incremental/invalidation/fastPath2/lib2/module.info

@@ -1,7 +1,6 @@
 STEP 0:
     dependencies: stdlib, lib1
     dirty: l2.kt
-
 STEP 1:
     dependencies: stdlib, lib1
-    flags: FP
+    flags: FP

js/js.translator/testData/incremental/invalidation/fastPath2/main/m.kt

@@ -1,2 +1,2 @@
 
-fun box() = qux()
+fun box() = if (qux() == 42) "OK" else "Fail"

js/js.translator/testData/incremental/invalidation/fastPath2/main/module.info

@@ -1,7 +1,6 @@
 STEP 0:
     dependencies: stdlib, lib1, lib2
     dirty: m.kt
-
 STEP 1:
     dependencies: stdlib, lib1, lib2
-    flags: FP
+    flags: FP

js/js.translator/testData/incremental/invalidation/fastPath2/project.info

@@ -2,6 +2,6 @@ MODULES: lib1, lib2, main
 
 STEP 0:
     libs: lib1, lib2, main
-
+    dirty js: stdlib, lib1, lib2, main
 STEP 1:
-    libs: lib1, lib2, main
+    libs: lib1, lib2, main

js/js.translator/testData/incremental/invalidation/functionDefaultParams/main/m.kt

@@ -1,2 +1,11 @@
 
-fun box() = foo()
+fun box(stepId: Int): String {
+    when (stepId) {
+        0 -> if (foo() != (42 + 77)) return "Fail"
+        1 -> if (foo() != (42 + 88)) return "Fail"
+        2 -> if (foo() != (42 + 88 + 11)) return "Fail"
+        3 -> if (foo() != (42 + 88 + 22)) return "Fail"
+        else -> return "Unknown"
+    }
+    return "OK"
+}

js/js.translator/testData/incremental/invalidation/functionDefaultParams/project.info

@@ -2,9 +2,13 @@ MODULES: lib1, main
 
 STEP 0:
     libs: lib1, main
+    dirty js: stdlib, lib1, main
 STEP 1:
     libs: lib1, main
+    dirty js: lib1
 STEP 2:
     libs: lib1, main
+    dirty js: lib1, main
 STEP 3:
     libs: lib1, main
+    dirty js: lib1

js/js.translator/testData/incremental/invalidation/functionSignature/main/m.kt

@@ -1,2 +1,23 @@
 
-fun box() = foo()
+fun isEqual(l: Any?, r: Any?) = if (l == r) true else null
+
+fun box(stepId: Int): String {
+    when (stepId) {
+        0, 8, 15, 16 -> isEqual(foo(), 42) ?: return "Fail"
+        1 -> isEqual(foo(), false) ?: return "Fail"
+        2 -> isEqual(foo(), 3.14) ?: return "Fail"
+        3, 5, 6, 12 -> isEqual(foo(), "string") ?: return "Fail"
+        4 -> isEqual(foo(), null) ?: return "Fail"
+        7 -> {
+            foo() // Unit
+            return "OK"
+        }
+        9 -> isEqual(foo(), 42 + 77) ?: return "Fail"
+        10 -> isEqual(foo(), 42 + 98 + 1) ?: return "Fail"
+        11 -> isEqual(foo(), 42 + 91) ?: return "Fail"
+        13 -> isEqual(foo(), 99) ?: return "Fail"
+        14 -> isEqual(foo(), 1L) ?: return "Fail"
+        else -> return "Unknown"
+    }
+    return "OK"
+}

js/js.translator/testData/incremental/invalidation/functionSignature/main/module.info

@@ -1,51 +1,3 @@
-STEP 0:
-    dependencies: stdlib, lib1
-    dirty: m.kt
-STEP 1:
-    dependencies: stdlib, lib1
-    dirty: m.kt
-STEP 2:
-    dependencies: stdlib, lib1
-    dirty: m.kt
-STEP 3:
-    dependencies: stdlib, lib1
-    dirty: m.kt
-STEP 4:
-    dependencies: stdlib, lib1
-    dirty: m.kt
-STEP 5:
-    dependencies: stdlib, lib1
-    dirty: m.kt
-STEP 6:
-    dependencies: stdlib, lib1
-    dirty: m.kt
-STEP 7:
-    dependencies: stdlib, lib1
-    dirty: m.kt
-STEP 8:
-    dependencies: stdlib, lib1
-    dirty: m.kt
-STEP 9:
-    dependencies: stdlib, lib1
-    dirty: m.kt
-STEP 10:
-    dependencies: stdlib, lib1
-    dirty: m.kt
-STEP 11:
-    dependencies: stdlib, lib1
-    dirty: m.kt
-STEP 12:
-    dependencies: stdlib, lib1
-    dirty: m.kt
-STEP 13:
-    dependencies: stdlib, lib1
-    dirty: m.kt
-STEP 14:
-    dependencies: stdlib, lib1
-    dirty: m.kt
-STEP 15:
-    dependencies: stdlib, lib1
-    dirty: m.kt
-STEP 16:
+STEP 0..16:
     dependencies: stdlib, lib1
     dirty: m.kt

js/js.translator/testData/incremental/invalidation/functionSignature/project.info

@@ -2,35 +2,13 @@ MODULES: lib1, main
 
 STEP 0:
     libs: lib1, main
-STEP 1:
+    dirty js: stdlib, lib1, main
+STEP 1..6:
     libs: lib1, main
-STEP 2:
+    dirty js: lib1, main
+STEP 7..8:
     libs: lib1, main
-STEP 3:
-    libs: lib1, main
-STEP 4:
-    libs: lib1, main
-STEP 5:
-    libs: lib1, main
-STEP 6:
-    libs: lib1, main
-STEP 7:
-    libs: lib1, main
-STEP 8:
-    libs: lib1, main
-STEP 9:
-    libs: lib1, main
-STEP 10:
-    libs: lib1, main
-STEP 11:
-    libs: lib1, main
-STEP 12:
-    libs: lib1, main
-STEP 13:
-    libs: lib1, main
-STEP 14:
-    libs: lib1, main
-STEP 15:
-    libs: lib1, main
-STEP 16:
+    dirty js: stdlib, lib1, main
+STEP 9..16:
     libs: lib1, main
+    dirty js: lib1, main

js/js.translator/testData/incremental/invalidation/genericFunctions/main/m.kt

@@ -1,2 +1,2 @@
 
-fun box() = foo("demo")
+fun box() = foo("OK")

js/js.translator/testData/incremental/invalidation/genericFunctions/main/module.info

@@ -1,15 +1,3 @@
-STEP 0:
-    dependencies: stdlib, lib1
-    dirty: m.kt
-STEP 1:
-    dependencies: stdlib, lib1
-    dirty: m.kt
-STEP 2:
-    dependencies: stdlib, lib1
-    dirty: m.kt
-STEP 3:
-    dependencies: stdlib, lib1
-    dirty: m.kt
-STEP 4:
+STEP 0..4:
     dependencies: stdlib, lib1
     dirty: m.kt

js/js.translator/testData/incremental/invalidation/genericFunctions/project.info

@@ -2,11 +2,7 @@ MODULES: lib1, main
 
 STEP 0:
     libs: lib1, main
-STEP 1:
-    libs: lib1, main
-STEP 2:
-    libs: lib1, main
-STEP 3:
-    libs: lib1, main
-STEP 4:
+    dirty js: stdlib, lib1, main
+STEP 1..4:
     libs: lib1, main
+    dirty js: lib1, main

js/js.translator/testData/incremental/invalidation/genericInlineFunctions/libProxy/module.info

@@ -3,25 +3,7 @@ STEP 0:
     modifications:
         U : proxy.kt.0.txt -> proxy.kt
     dirty: proxy.kt
-STEP 1:
-    dependencies: stdlib
-    flags: FP
-STEP 2:
-    dependencies: stdlib
-    flags: FP
-STEP 3:
-    dependencies: stdlib
-    flags: FP
-STEP 4:
-    dependencies: stdlib
-    flags: FP
-STEP 5:
-    dependencies: stdlib
-    flags: FP
-STEP 6:
-    dependencies: stdlib
-    flags: FP
-STEP 7:
+STEP 1..7:
     dependencies: stdlib
     flags: FP
 STEP 8:
@@ -29,25 +11,7 @@ STEP 8:
     modifications:
         U : proxy.kt.1.txt -> proxy.kt
     dirty: proxy.kt
-STEP 9:
-    dependencies: stdlib, lib1
-    dirty: proxy.kt
-STEP 10:
-    dependencies: stdlib, lib1
-    dirty: proxy.kt
-STEP 11:
-    dependencies: stdlib, lib1
-    dirty: proxy.kt
-STEP 12:
-    dependencies: stdlib, lib1
-    dirty: proxy.kt
-STEP 13:
-    dependencies: stdlib, lib1
-    dirty: proxy.kt
-STEP 14:
-    dependencies: stdlib, lib1
-    dirty: proxy.kt
-STEP 15:
+STEP 9..15:
     dependencies: stdlib, lib1
     dirty: proxy.kt
 STEP 16:
@@ -55,24 +19,6 @@ STEP 16:
     modifications:
         U : proxy.kt.2.txt -> proxy.kt
     dirty: proxy.kt
-STEP 17:
-    dependencies: stdlib, lib1
-    dirty: proxy.kt
-STEP 18:
-    dependencies: stdlib, lib1
-    dirty: proxy.kt
-STEP 19:
-    dependencies: stdlib, lib1
-    dirty: proxy.kt
-STEP 20:
-    dependencies: stdlib, lib1
-    dirty: proxy.kt
-STEP 21:
-    dependencies: stdlib, lib1
-    dirty: proxy.kt
-STEP 22:
-    dependencies: stdlib, lib1
-    dirty: proxy.kt
-STEP 23:
+STEP 17..23:
     dependencies: stdlib, lib1
     dirty: proxy.kt

js/js.translator/testData/incremental/invalidation/genericInlineFunctions/main/m.kt

@@ -1,2 +1,14 @@
 
-fun box() = foo("demo")
+fun isEqual(l: Any?, r: Any?) = if (l == r) true else null
+
+fun box(stepId: Int): String {
+    when (stepId) {
+        in 0..5 -> isEqual(foo("test"), 123) ?: return "Fail"
+        in 8..13 -> isEqual(foo("test"), 123) ?: return "Fail"
+        in 16..21 -> isEqual(foo("test"), 123) ?: return "Fail"
+        6, 14, 22 -> isEqual(foo("test"), 99) ?: return "Fail"
+        7, 15, 23 -> isEqual(foo("test"), "test") ?: return "Fail"
+        else -> return "Unknown"
+    }
+    return "OK"
+}

js/js.translator/testData/incremental/invalidation/genericInlineFunctions/main/m.proxy.kt.txt

@@ -1,2 +1,14 @@
 
-fun box() = foo_proxy("demo")
+fun isEqual(l: Any?, r: Any?) = if (l == r) true else null
+
+fun box(stepId: Int): String {
+    when (stepId) {
+        in 0..5 -> isEqual(foo_proxy("test"), 123) ?: return "Fail"
+        in 8..13 -> isEqual(foo_proxy("test"), 123) ?: return "Fail"
+        in 16..21 -> isEqual(foo_proxy("test"), 123) ?: return "Fail"
+        6, 14, 22 -> isEqual(foo_proxy("test"), 99) ?: return "Fail"
+        7, 15, 23 -> isEqual(foo_proxy("test"), "test") ?: return "Fail"
+        else -> return "Unknown"
+    }
+    return "OK"
+}

js/js.translator/testData/incremental/invalidation/genericInlineFunctions/main/module.info

@@ -1,25 +1,4 @@
-STEP 0:
-    dependencies: stdlib, lib1
-    dirty: m.kt
-STEP 1:
-    dependencies: stdlib, lib1
-    dirty: m.kt
-STEP 2:
-    dependencies: stdlib, lib1
-    dirty: m.kt
-STEP 3:
-    dependencies: stdlib, lib1
-    dirty: m.kt
-STEP 4:
-    dependencies: stdlib, lib1
-    dirty: m.kt
-STEP 5:
-    dependencies: stdlib, lib1
-    dirty: m.kt
-STEP 6:
-    dependencies: stdlib, lib1
-    dirty: m.kt
-STEP 7:
+STEP 0..7:
     dependencies: stdlib, lib1
     dirty: m.kt
 STEP 8:
@@ -27,48 +6,6 @@ STEP 8:
     modifications:
         U : m.proxy.kt.txt -> m.kt
     dirty: m.kt
-STEP 9:
-    dependencies: stdlib, lib1, libProxy
-    dirty: m.kt
-STEP 10:
-    dependencies: stdlib, lib1, libProxy
-    dirty: m.kt
-STEP 11:
-    dependencies: stdlib, lib1, libProxy
-    dirty: m.kt
-STEP 12:
-    dependencies: stdlib, lib1, libProxy
-    dirty: m.kt
-STEP 13:
-    dependencies: stdlib, lib1, libProxy
-    dirty: m.kt
-STEP 14:
-    dependencies: stdlib, lib1, libProxy
-    dirty: m.kt
-STEP 15:
-    dependencies: stdlib, lib1, libProxy
-    dirty: m.kt
-STEP 16:
-    dependencies: stdlib, lib1, libProxy
-    dirty: m.kt
-STEP 17:
-    dependencies: stdlib, lib1, libProxy
-    dirty: m.kt
-STEP 18:
-    dependencies: stdlib, lib1, libProxy
-    dirty: m.kt
-STEP 19:
-    dependencies: stdlib, lib1, libProxy
-    dirty: m.kt
-STEP 20:
-    dependencies: stdlib, lib1, libProxy
-    dirty: m.kt
-STEP 21:
-    dependencies: stdlib, lib1, libProxy
-    dirty: m.kt
-STEP 22:
-    dependencies: stdlib, lib1, libProxy
-    dirty: m.kt
-STEP 23:
+STEP 9..23:
     dependencies: stdlib, lib1, libProxy
     dirty: m.kt

js/js.translator/testData/incremental/invalidation/genericInlineFunctions/project.info

@@ -2,49 +2,22 @@ MODULES: lib1, main, libProxy
 
 STEP 0:
     libs: lib1, main
-STEP 1:
+    dirty js: stdlib, lib1, main
+STEP 1..5:
     libs: lib1, main
-STEP 2:
+    dirty js: lib1, main
+STEP 6..7:
     libs: lib1, main
-STEP 3:
-    libs: lib1, main
-STEP 4:
-    libs: lib1, main
-STEP 5:
-    libs: lib1, main
-STEP 6:
-    libs: lib1, main
-STEP 7:
-    libs: lib1, main
-STEP 8:
+    dirty js: stdlib, lib1, main
+STEP 8..13:
     libs: lib1, libProxy, main
-STEP 9:
+    dirty js: lib1, libProxy, main
+STEP 14..16:
     libs: lib1, libProxy, main
-STEP 10:
+    dirty js: stdlib, lib1, libProxy, main
+STEP 17..21:
     libs: lib1, libProxy, main
-STEP 11:
-    libs: lib1, libProxy, main
-STEP 12:
-    libs: lib1, libProxy, main
-STEP 13:
-    libs: lib1, libProxy, main
-STEP 14:
-    libs: lib1, libProxy, main
-STEP 15:
-    libs: lib1, libProxy, main
-STEP 16:
-    libs: lib1, libProxy, main
-STEP 17:
-    libs: lib1, libProxy, main
-STEP 18:
-    libs: lib1, libProxy, main
-STEP 19:
-    libs: lib1, libProxy, main
-STEP 20:
-    libs: lib1, libProxy, main
-STEP 21:
-    libs: lib1, libProxy, main
-STEP 22:
-    libs: lib1, libProxy, main
-STEP 23:
+    dirty js: lib1, libProxy, main
+STEP 22..23:
     libs: lib1, libProxy, main
+    dirty js: stdlib, lib1, libProxy, main

js/js.translator/testData/incremental/invalidation/inlineBecomeNonInline/main/m.kt

@@ -1,2 +1,9 @@
 
-fun box() = foo()
+fun box(stepId: Int): String {
+    when(stepId) {
+        0, 1 -> if (foo() != 42) return "Fail"
+        2 -> if (foo() != 77) return "Fail"
+        else -> return "Unknown"
+    }
+    return "OK"
+}

js/js.translator/testData/incremental/invalidation/inlineBecomeNonInline/main/module.info

@@ -1,7 +1,4 @@
-STEP 0:
-    dependencies: stdlib, lib1
-    dirty: m.kt
-STEP 1:
+STEP 0..1:
     dependencies: stdlib, lib1
     dirty: m.kt
 STEP 2:

js/js.translator/testData/incremental/invalidation/inlineBecomeNonInline/project.info

@@ -1,8 +1,8 @@
 MODULES: lib1, main
 
-STEP 0:
-    libs: lib1, main
-STEP 1:
+STEP 0..1:
     libs: lib1, main
+    dirty js: stdlib, lib1, main
 STEP 2:
     libs: lib1, main
+    dirty js: lib1

js/js.translator/testData/incremental/invalidation/inlineFunctionAsParam/main/m.kt

@@ -1,6 +1,53 @@
 
+fun isEqual(l: Any?, r: Any?) = if (l == r) true else null
+
 inline fun test1(x: () -> Any) = x()
 fun test2(x: () -> Any) = x()
 inline fun test3(x: () -> Any) = x()
 
-fun box() = test1(::foo1).toString() + test2(::foo2).toString() + test3 { foo3() }.toString()
+fun box(stepId: Int): String {
+    when (stepId) {
+        0 -> {
+            isEqual(test1(::foo1), "foo1") ?: return "Fail foo1"
+            isEqual(test2(::foo2), "foo2") ?: return "Fail foo2"
+            isEqual(test3 { foo3() }, "foo3") ?: return "Fail foo3"
+        }
+        1 -> {
+            isEqual(test1(::foo1), "foo1 update") ?: return "Fail foo1"
+            isEqual(test2(::foo2), "foo2") ?: return "Fail foo2"
+            isEqual(test3 { foo3() }, "foo3") ?: return "Fail foo3"
+        }
+        2 -> {
+            isEqual(test1(::foo1), "foo1 update") ?: return "Fail foo1"
+            isEqual(test2(::foo2), "foo2 update") ?: return "Fail foo2"
+            isEqual(test3 { foo3() }, "foo3") ?: return "Fail foo3"
+        }
+        3 -> {
+            isEqual(test1(::foo1), 77) ?: return "Fail foo1"
+            isEqual(test2(::foo2), "foo2 update") ?: return "Fail foo2"
+            isEqual(test3 { foo3() }, "foo3") ?: return "Fail foo3"
+        }
+        4 -> {
+            isEqual(test1(::foo1), 77) ?: return "Fail foo1"
+            isEqual(test2(::foo2), 88) ?: return "Fail foo2"
+            isEqual(test3 { foo3() }, "foo3") ?: return "Fail foo3"
+        }
+        5, 6 -> {
+            isEqual(test1(::foo1), 77) ?: return "Fail foo1"
+            isEqual(test2(::foo2), 88) ?: return "Fail foo2"
+            isEqual(test3 { foo3() }, "foo3 update") ?: return "Fail foo3"
+        }
+        7, 8 -> {
+            isEqual(test1(::foo1), 99) ?: return "Fail foo1"
+            isEqual(test2(::foo2), 88) ?: return "Fail foo2"
+            isEqual(test3 { foo3() }, "foo3 update") ?: return "Fail foo3"
+        }
+        9 -> {
+            isEqual(test1(::foo1), 88) ?: return "Fail foo1"
+            isEqual(test2(::foo2), 88) ?: return "Fail foo2"
+            isEqual(test3 { foo3() }, "foo3 update") ?: return "Fail foo3"
+        }
+        else -> return "Unknown"
+    }
+    return "OK"
+}

js/js.translator/testData/incremental/invalidation/inlineFunctionAsParam/main/module.info

@@ -1,28 +1,8 @@
-STEP 0:
+STEP 0..1:
     dependencies: stdlib, lib1
     dirty: m.kt
-STEP 1:
-    dependencies: stdlib, lib1
 STEP 2:
     dependencies: stdlib, lib1
-STEP 3:
-    dependencies: stdlib, lib1
-    dirty: m.kt
-STEP 4:
-    dependencies: stdlib, lib1
-    dirty: m.kt
-STEP 5:
-    dependencies: stdlib, lib1
-    dirty: m.kt
-STEP 6:
-    dependencies: stdlib, lib1
-    dirty: m.kt
-STEP 7:
-    dependencies: stdlib, lib1
-    dirty: m.kt
-STEP 8:
-    dependencies: stdlib, lib1
-    dirty: m.kt
-STEP 9:
+STEP 3..9:
     dependencies: stdlib, lib1
     dirty: m.kt

js/js.translator/testData/incremental/invalidation/inlineFunctionAsParam/project.info

@@ -2,21 +2,13 @@ MODULES: lib1, main
 
 STEP 0:
     libs: lib1, main
+    dirty js: stdlib, lib1, main
 STEP 1:
     libs: lib1, main
+    dirty js: lib1, main
 STEP 2:
     libs: lib1, main
-STEP 3:
-    libs: lib1, main
-STEP 4:
-    libs: lib1, main
-STEP 5:
-    libs: lib1, main
-STEP 6:
-    libs: lib1, main
-STEP 7:
-    libs: lib1, main
-STEP 8:
-    libs: lib1, main
-STEP 9:
+    dirty js: lib1
+STEP 3..9:
     libs: lib1, main
+    dirty js: lib1, main

js/js.translator/testData/incremental/invalidation/inlineFunctionDefaultParams/main/m.kt

@@ -1,2 +1,9 @@
 
-fun box() = foo()
+fun box(stepId: Int): String {
+    when (stepId) {
+        0 -> if (foo() != (42 + 77)) return "Fail"
+        1, 2, 3 -> if (foo() != (42 + 88)) return "Fail"
+        else -> return "Unknown"
+    }
+    return "OK"
+}

js/js.translator/testData/incremental/invalidation/inlineFunctionDefaultParams/main/module.info

@@ -1,12 +1,3 @@
-STEP 0:
-    dependencies: stdlib, lib1
-    dirty: m.kt
-STEP 1:
-    dependencies: stdlib, lib1
-    dirty: m.kt
-STEP 2:
-    dependencies: stdlib, lib1
-    dirty: m.kt
-STEP 3:
+STEP 0..3:
     dependencies: stdlib, lib1
     dirty: m.kt

js/js.translator/testData/incremental/invalidation/inlineFunctionDefaultParams/project.info

@@ -2,9 +2,7 @@ MODULES: lib1, main
 
 STEP 0:
     libs: lib1, main
-STEP 1:
-    libs: lib1, main
-STEP 2:
-    libs: lib1, main
-STEP 3:
+    dirty js: stdlib, lib1, main
+STEP 1..3:
     libs: lib1, main
+    dirty js: lib1, main

js/js.translator/testData/incremental/invalidation/jsCode/lib1/l1.kt.1.txt

@@ -1 +1 @@
-inline fun foo() = js("40 + 2")
+inline fun foo() = js("42 + 1")

js/js.translator/testData/incremental/invalidation/jsCode/lib1/l1.kt.2.txt

@@ -1 +1 @@
-inline fun foo() = js("'42'")
+inline fun foo() = js("'44'")

js/js.translator/testData/incremental/invalidation/jsCode/main/m.kt

@@ -1,2 +1,11 @@
 
-fun box() = foo()
+fun box(stepId: Int): String {
+    when (stepId) {
+        0 -> if (foo() != 42) return "Fail"
+        1 -> if (foo() != 43) return "Fail"
+        2 -> if (foo() != "44") return "Fail"
+        3 -> if (foo() != "hello") return "Fail"
+        else -> return "Unknown"
+    }
+    return "OK"
+}

js/js.translator/testData/incremental/invalidation/jsCode/main/module.info

@@ -1,13 +1,3 @@
-STEP 0:
+STEP 0..3:
     dependencies: stdlib, lib1
     dirty: m.kt
-STEP 1:
-    dependencies: stdlib, lib1
-    dirty: m.kt
-STEP 2:
-    dependencies: stdlib, lib1
-    dirty: m.kt
-STEP 3:
-    dependencies: stdlib, lib1
-    dirty: m.kt
-

js/js.translator/testData/incremental/invalidation/jsCode/project.info

@@ -2,9 +2,7 @@ MODULES: lib1, main
 
 STEP 0:
     libs: lib1, main
-STEP 1:
-    libs: lib1, main
-STEP 2:
-    libs: lib1, main
-STEP 3:
+    dirty js: stdlib, lib1, main
+STEP 1..3:
     libs: lib1, main
+    dirty js: lib1, main

js/js.translator/testData/incremental/invalidation/jsExport/main/m.kt

@@ -1,2 +1,6 @@
 
-fun box() = foo() + gaz()
+fun box(): String {
+    if (foo() != 77) return "Fail foo"
+    if (gaz() != 99) return "Fail gaz"
+    return "OK"
+}

js/js.translator/testData/incremental/invalidation/jsExport/main/module.info

@@ -1,18 +1,5 @@
-STEP 0:
+STEP 0..3:
     dependencies: stdlib, lib1
     dirty: m.kt
-STEP 1:
-    dependencies: stdlib, lib1
-    dirty: m.kt
-STEP 2:
-    dependencies: stdlib, lib1
-    dirty: m.kt
-STEP 3:
-    dependencies: stdlib, lib1
-    dirty: m.kt
-STEP 4:
-    dependencies: stdlib, lib1
-STEP 5:
-    dependencies: stdlib, lib1
-STEP 6:
+STEP 4..6:
     dependencies: stdlib, lib1

js/js.translator/testData/incremental/invalidation/jsExport/project.info

@@ -2,15 +2,10 @@ MODULES: lib1, main
 
 STEP 0:
     libs: lib1, main
-STEP 1:
+    dirty js: stdlib, lib1, main
+STEP 1..3:
     libs: lib1, main
-STEP 2:
-    libs: lib1, main
-STEP 3:
-    libs: lib1, main
-STEP 4:
-    libs: lib1, main
-STEP 5:
-    libs: lib1, main
-STEP 6:
+    dirty js: lib1, main
+STEP 4..6:
     libs: lib1, main
+    dirty js: lib1

js/js.translator/testData/incremental/invalidation/mainModuleInvalidation/main/m.kt

@@ -1,2 +1,5 @@
 
-fun box() = qux()
+fun box(): String {
+    if (qux() != 42) return "Fail"
+    return "OK"
+}

js/js.translator/testData/incremental/invalidation/mainModuleInvalidation/main/m.kt.1.txt

@@ -1,2 +1,5 @@
 
-fun box() = qux() + 88
+fun box(): String {
+    if (qux() != 42) return "Fail qux"
+    return "OK"
+}

js/js.translator/testData/incremental/invalidation/mainModuleInvalidation/main/module.info

@@ -1,7 +1,6 @@
 STEP 0:
     dependencies: stdlib, lib1
     dirty: m.kt, m0.kt, m1.kt
-
 STEP 1:
     dependencies: stdlib, lib1
     modifications:

js/js.translator/testData/incremental/invalidation/mainModuleInvalidation/project.info

@@ -2,6 +2,7 @@ MODULES: lib1, main
 
 STEP 0:
     libs: lib1, main
-
+    dirty js: stdlib, lib1, main
 STEP 1:
     libs: lib1, main
+    dirty js: main

js/js.translator/testData/incremental/invalidation/moveFilesBetweenModules/lib1/module.info

@@ -5,8 +5,6 @@ STEP 1:
     dependencies: stdlib
     modifications:
         D : l12.kt
-    dirty:
-
 STEP 2:
     dependencies: stdlib
     modifications:

js/js.translator/testData/incremental/invalidation/moveFilesBetweenModules/lib2/module.info

@@ -1,15 +1,13 @@
 STEP 0:
     dependencies: stdlib, lib1
     dirty: l21.kt
-
 STEP 1:
     dependencies: stdlib, lib1
     modifications:
         U : l22.kt.1 -> l22.kt
     dirty: l21.kt, l22.kt
-
 STEP 2:
     dependencies: stdlib, lib1
     modifications:
         D : l22.kt
-    dirty: l21.kt
+    dirty: l21.kt

js/js.translator/testData/incremental/invalidation/moveFilesBetweenModules/lib3/module.info

@@ -1,11 +1,3 @@
-STEP 0:
+STEP 0..2:
     dependencies: stdlib, lib1, lib2
     dirty: l3.kt
-
-STEP 1:
-    dependencies: stdlib, lib1, lib2
-    dirty: l3.kt
-
-STEP 2:
-    dependencies: stdlib, lib1, lib2
-    dirty: l3.kt

js/js.translator/testData/incremental/invalidation/moveFilesBetweenModules/main/m.kt

@@ -1,2 +1,10 @@
 
-fun box() = dex(4, 2)
+fun box(stepId: Int): String {
+    when (stepId) {
+        0 -> if (dex(4, 2) != 11) return "Fail"
+        1 -> if (dex(4, 2) != 10) return "Fail"
+        2 -> if (dex(4, 2) != 9) return "Fail"
+        else -> return "Unknown"
+    }
+    return "OK"
+}

js/js.translator/testData/incremental/invalidation/moveFilesBetweenModules/main/module.info

@@ -1,11 +1,3 @@
-STEP 0:
+STEP 0..2:
     dependencies: stdlib, lib1, lib2, lib3
     dirty: m.kt
-
-STEP 1:
-    dependencies: stdlib, lib1, lib2, lib3
-    dirty: m.kt
-
-STEP 2:
-    dependencies: stdlib, lib1, lib2, lib3
-    dirty: m.kt

js/js.translator/testData/incremental/invalidation/moveFilesBetweenModules/project.info

@@ -2,9 +2,7 @@ MODULES: lib1, lib2, lib3, main
 
 STEP 0:
     libs: lib1, lib2, lib3, main
-
-STEP 1:
+    dirty js: stdlib, lib1, lib2, lib3, main
+STEP 1..2:
     libs: lib1, lib2, lib3, main
-
-STEP 2:
-    libs: lib1, lib2, lib3, main
+    dirty js: lib1, lib2, lib3, main

js/js.translator/testData/incremental/invalidation/moveInlineFunctionBetweenModules/lib2/module.info

@@ -1,9 +1,8 @@
 STEP 0:
     dependencies: stdlib, lib1
     dirty: l2.kt
-
 STEP 1:
     dependencies: stdlib, lib1
     modifications:
         U : l22.kt.1 -> l22.kt
-    dirty: l2.kt, l22.kt
+    dirty: l2.kt, l22.kt

js/js.translator/testData/incremental/invalidation/moveInlineFunctionBetweenModules/lib3/module.info

@@ -1,7 +1,3 @@
-STEP 0:
+STEP 0..1:
     dependencies: stdlib, lib1, lib2
     dirty: l3.kt
-
-STEP 1:
-    dependencies: stdlib, lib1, lib2
-    dirty: l3.kt

js/js.translator/testData/incremental/invalidation/moveInlineFunctionBetweenModules/main/m.kt

@@ -1,2 +1,9 @@
 
-fun box() = dex(4, 2)
+fun box(stepId: Int): String {
+    when (stepId) {
+        0 -> if (dex(4, 2) != 11) return "Fail"
+        1 -> if (dex(4, 2) != 18) return "Fail"
+        else -> return "Unknown"
+    }
+    return "OK"
+}

js/js.translator/testData/incremental/invalidation/moveInlineFunctionBetweenModules/main/module.info

@@ -1,7 +1,3 @@
-STEP 0:
+STEP 0..1:
     dependencies: stdlib, lib1, lib2, lib3
     dirty: m.kt
-
-STEP 1:
-    dependencies: stdlib, lib1, lib2, lib3
-    dirty: m.kt

js/js.translator/testData/incremental/invalidation/moveInlineFunctionBetweenModules/project.info

@@ -2,6 +2,7 @@ MODULES: lib1, lib2, lib3, main
 
 STEP 0:
     libs: lib1, lib2, lib3, main
-
+    dirty js: stdlib, lib1, lib2, lib3, main
 STEP 1:
-    libs: lib1, lib2, lib3, main
+    libs: lib1, lib2, lib3, main
+    dirty js: lib1, lib2, lib3, main

js/js.translator/testData/incremental/invalidation/nonInlineBecomeInline/main/m.kt

@@ -1,2 +1,10 @@
 
-fun box() = foo()
+fun box(stepId: Int): String {
+    when (stepId) {
+        0 -> if (foo() != 42) return "Fail"
+        1 -> if (foo() != 33) return "Fail"
+        2 -> if (foo() != 77) return "Fail"
+        else -> return "Unknown"
+    }
+    return "OK"
+}

js/js.translator/testData/incremental/invalidation/nonInlineBecomeInline/main/module.info

@@ -1,7 +1,5 @@
 STEP 0:
     dependencies: stdlib, lib1
     dirty: m.kt
-STEP 1:
-    dependencies: stdlib, lib1
-STEP 2:
+STEP 1..2:
     dependencies: stdlib, lib1

js/js.translator/testData/incremental/invalidation/nonInlineBecomeInline/project.info

@@ -2,7 +2,7 @@ MODULES: lib1, main
 
 STEP 0:
     libs: lib1, main
-STEP 1:
-    libs: lib1, main
-STEP 2:
+    dirty js: stdlib, lib1, main
+STEP 1..2:
     libs: lib1, main
+    dirty js: lib1

js/js.translator/testData/incremental/invalidation/privateInlineFunction1/lib2/module.info

@@ -1,7 +1,5 @@
 STEP 0:
     dependencies: stdlib, lib1
     dirty: l2.kt
-
 STEP 1:
     dependencies: stdlib, lib1
-    dirty:

js/js.translator/testData/incremental/invalidation/privateInlineFunction1/main/m.kt

@@ -1,2 +1,9 @@
 
-fun box() = qux(4, 2)
+fun box(stepId: Int): String {
+    when (stepId) {
+        0 -> if (qux(4, 2) != -8) return "Fail"
+        1 -> if (qux(4, 2) != -4) return "Fail"
+        else -> return "Unknown"
+    }
+    return "OK"
+}

js/js.translator/testData/incremental/invalidation/privateInlineFunction1/main/module.info

@@ -1,7 +1,5 @@
 STEP 0:
     dependencies: stdlib, lib1, lib2
     dirty: m.kt
-
 STEP 1:
     dependencies: stdlib, lib1, lib2
-    dirty:

js/js.translator/testData/incremental/invalidation/privateInlineFunction1/project.info

@@ -2,6 +2,7 @@ MODULES: lib1, lib2, main
 
 STEP 0:
     libs: lib1, lib2, main
-
+    dirty js: stdlib, lib1, lib2, main
 STEP 1:
-    libs: lib1, lib2, main
+    libs: lib1, lib2, main
+    dirty js: lib1

js/js.translator/testData/incremental/invalidation/removeFile/lib2/module.info

@@ -1,8 +1,7 @@
 STEP 0:
     dependencies: stdlib, lib1
     dirty: l2_0.kt, l2_1.kt
-
 STEP 1:
     dependencies: stdlib, lib1
     modifications:
-        D : l2_1.kt
+        D : l2_1.kt

js/js.translator/testData/incremental/invalidation/removeFile/main/m.kt

@@ -1,2 +1,6 @@
 
-fun box() = qux0() + qux1()
+fun box(): String {
+    if (qux0() != 42) return "Fail"
+    if (qux1() != 24) return "Fail"
+    return "OK"
+}

js/js.translator/testData/incremental/invalidation/removeFile/main/m.kt.new

@@ -1,2 +1,5 @@
 
-fun box() = qux0()
+fun box(): String {
+    if (qux0() != 42) return "Fail"
+    return "OK"
+}

js/js.translator/testData/incremental/invalidation/removeFile/main/module.info

@@ -1,9 +1,8 @@
 STEP 0:
     dependencies: stdlib, lib1, lib2
     dirty: m.kt
-
 STEP 1:
     dependencies: stdlib, lib1, lib2
     modifications:
         U : m.kt.new -> m.kt
-    dirty: m.kt
+    dirty: m.kt

js/js.translator/testData/incremental/invalidation/removeFile/project.info

@@ -2,6 +2,7 @@ MODULES: lib1, lib2, main
 
 STEP 0:
     libs: lib1, lib2, main
-
+    dirty js: stdlib, lib1, lib2, main
 STEP 1:
-    libs: lib1, lib2, main
+    libs: lib1, lib2, main
+    dirty js: lib1, lib2, main

js/js.translator/testData/incremental/invalidation/removeModule/lib1/module.info

@@ -1,7 +1,6 @@
 STEP 0:
     dependencies: stdlib
     dirty: l1.kt
-
 STEP 1:
     dependencies: stdlib
-    flags: FP
+    flags: FP UNUSED

js/js.translator/testData/incremental/invalidation/removeModule/lib2/module.info

@@ -1,9 +1,8 @@
 STEP 0:
     dependencies: stdlib, lib1
     dirty: l2.kt
-
 STEP 1:
     dependencies: stdlib
     modifications:
         U : l2.kt.1 -> l2.kt
-    dirty: l2.kt
+    dirty: l2.kt

js/js.translator/testData/incremental/invalidation/removeModule/main/m.kt

@@ -1,2 +1,9 @@
 
-fun box() = qux()
+fun box(stepId: Int): String {
+    when (stepId) {
+        0 -> if (qux() != 42) return "Fail"
+        1 -> if (qux() != 99) return "Fail"
+        else -> "Unknown"
+    }
+    return "OK"
+}

js/js.translator/testData/incremental/invalidation/removeModule/main/module.info

@@ -1,6 +1,5 @@
 STEP 0:
     dependencies: stdlib, lib1, lib2
     dirty: m.kt
-
 STEP 1:
     dependencies: stdlib, lib2