[JS IR IC] Remove JS files of the deleted modules from the out directory

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

@@ -10,6 +10,7 @@ import org.jetbrains.kotlin.ir.backend.js.export.toTypeScript
 import org.jetbrains.kotlin.js.backend.ast.JsProgram
 import org.jetbrains.kotlin.serialization.js.ModuleKind
 import java.io.File
+import java.nio.file.Files
 
 abstract class CompilationOutputs {
     var dependencies: Collection<Pair<String, CompilationOutputs>> = emptyList()
@@ -20,29 +21,35 @@ abstract class CompilationOutputs {
 
     abstract fun writeJsCode(outputJsFile: File, outputJsMapFile: File)
 
-    fun writeAll(outputDir: File, outputName: String, genDTS: Boolean, moduleName: String, moduleKind: ModuleKind): List<String> {
+    fun writeAll(outputDir: File, outputName: String, genDTS: Boolean, moduleName: String, moduleKind: ModuleKind): Collection<File> {
-        val writtenJsFiles = ArrayList<String>(dependencies.size + 1)
+        val writtenFiles = LinkedHashSet<File>(2 * (dependencies.size + 1) + 1)
 
-        val outputJsFile = outputDir.resolve("$outputName.js")
+        fun File.writeAsJsFile(out: CompilationOutputs) {
+            parentFile.mkdirs()
+            val jsMapFile = mapForJsFile
+            val jsFile = canonicalFile
+            out.writeJsCode(jsFile, jsMapFile)
 
-        outputJsFile.parentFile.mkdirs()
+            writtenFiles += jsFile
-        writeJsCode(outputJsFile, outputJsFile.mapForJsFile)
+            writtenFiles += jsMapFile
+        }
 
         dependencies.forEach { (name, content) ->
-            outputDir.resolve("$name.js").let { depJsFile ->
+            outputDir.resolve("$name.js").writeAsJsFile(content)
-                depJsFile.parentFile.mkdirs()
-                content.writeJsCode(depJsFile, depJsFile.mapForJsFile)
-                writtenJsFiles += depJsFile.absolutePath
-            }
         }
 
-        writtenJsFiles += outputJsFile.absolutePath
+        val outputJsFile = outputDir.resolve("$outputName.js")
+        outputJsFile.writeAsJsFile(this)
 
         if (genDTS) {
-            outputJsFile.dtsForJsFile.writeText(getFullTsDefinition(moduleName, moduleKind))
+            val dtsFile = outputJsFile.dtsForJsFile
+            dtsFile.writeText(getFullTsDefinition(moduleName, moduleKind))
+            writtenFiles += dtsFile
         }
 
-        return writtenJsFiles
+        Files.walk(outputDir.toPath()).map { it.toFile() }.filter { it != outputDir && it !in writtenFiles }.forEach(File::delete)
+
+        return writtenFiles
     }
 
     fun getFullTsDefinition(moduleName: String, moduleKind: ModuleKind): String {
@@ -51,10 +58,10 @@ abstract class CompilationOutputs {
     }
 
     private val File.mapForJsFile
-        get() = resolveSibling("$name.map")
+        get() = resolveSibling("$name.map").canonicalFile
 
     private val File.dtsForJsFile
-        get() = resolveSibling("$nameWithoutExtension.d.ts")
+        get() = resolveSibling("$nameWithoutExtension.d.ts").canonicalFile
 }
 
 class CompilationOutputsBuilt(

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

@@ -227,7 +227,6 @@ abstract class AbstractInvalidationTest : KotlinTestWithEnvironment() {
         }
 
         private fun prepareExternalJsFiles(): MutableList<String> {
-            jsDir.invalidateDir()
             return testDir.filesInDir.mapNotNullTo(mutableListOf(MODULE_EMULATION_FILE)) { file ->
                 file.takeIf { it.name.isAllowedJsFile() }?.readText()?.let { jsCode ->
                     val externalModule = jsDir.resolve(file.name)
@@ -239,16 +238,16 @@ abstract class AbstractInvalidationTest : KotlinTestWithEnvironment() {
 
 
         private fun verifyJsCode(stepId: Int, mainModuleName: String, jsOutput: CompilationOutputs) {
-            val files = prepareExternalJsFiles()
+            val compiledJsFiles = jsOutput.writeAll(jsDir, mainModuleName, true, mainModuleName, JS_MODULE_KIND).filter {
-            val compiledJsFiles = jsOutput.writeAll(jsDir, mainModuleName, true, mainModuleName, JS_MODULE_KIND)
+                it.extension == "js"
+            }
             for (jsCodeFile in compiledJsFiles) {
-                val jsFile = File(jsCodeFile)
+                jsCodeFile.writeAsJsModule(jsCodeFile.readText(), "./${jsCodeFile.name}")
-                jsFile.writeAsJsModule(jsFile.readText(), "./${jsFile.name}")
             }
 
             try {
                 V8IrJsTestChecker.checkWithTestFunctionArgs(
-                    files = files + compiledJsFiles,
+                    files = compiledJsFiles.mapTo(prepareExternalJsFiles()) { it.absolutePath },
                     testModuleName = "./$mainModuleName.js",
                     testPackageName = null,
                     testFunctionName = BOX_FUNCTION_NAME,

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

@@ -272,14 +272,16 @@ class JsIrBackendFacade(
     }
 
     private fun CompilationOutputs.writeTo(outputFile: File, moduleId: String, moduleKind: ModuleKind) {
-        val allJsFiles = writeAll(outputFile.parentFile, outputFile.nameWithoutExtension, false, moduleId, moduleKind)
+        val allJsFiles = writeAll(outputFile.parentFile, outputFile.nameWithoutExtension, false, moduleId, moduleKind).filter {
+            it.extension == "js"
+        }
 
-        val mainModuleFile = File(allJsFiles.last())
+        val mainModuleFile = allJsFiles.last()
         mainModuleFile.fixJsFile(outputFile, moduleId, moduleKind)
 
         dependencies.map { it.first }.zip(allJsFiles.dropLast(1)).forEach { (depModuleId, builtJsFilePath) ->
             val newFile = outputFile.augmentWithModuleName(depModuleId)
-            File(builtJsFilePath).fixJsFile(newFile, depModuleId, moduleKind)
+            builtJsFilePath.fixJsFile(newFile, depModuleId, moduleKind)
         }
     }
 

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

@@ -169,8 +169,8 @@ abstract class AbstractJsKLibABITestCase : KtUsefulTestCase() {
             buildBinaryNoIC(configuration, mainModuleKlibFile, allDependencies)
 
         val binariesDir = File(buildDir, BIN_DIR_NAME).also { it.mkdirs() }
-        val binaries = compilationOutputs.writeAll(binariesDir, MAIN_MODULE_NAME, false, MAIN_MODULE_NAME, ModuleKind.PLAIN).map {
+        val binaries = compilationOutputs.writeAll(binariesDir, MAIN_MODULE_NAME, false, MAIN_MODULE_NAME, ModuleKind.PLAIN).filter {
-            File(it)
+            it.extension == "js"
         }
 
         executeAndCheckBinaries(MAIN_MODULE_NAME, binaries)