[JPS] Fix JS incremental compilation

Disable Idea JPS build mechanism for marking all sources of common output if one of them is dirty
Add source-to-outputs map for correctly removing Kotlin/JS outputs

#KT-45763 Fixed
#KT-44351 Fixed

build-common/src/org/jetbrains/kotlin/build/generatedFiles.kt

@@ -39,4 +39,4 @@ class GeneratedJvmClass(
     }
 }
 
-fun File.isModuleMappingFile() = extension == ModuleMapping.MAPPING_FILE_EXT && parentFile.name == "META-INF"
+fun File.isModuleMappingFile() = extension == ModuleMapping.MAPPING_FILE_EXT && parentFile.name == "META-INF"

build-common/src/org/jetbrains/kotlin/incremental/IncrementalJsCache.kt

@@ -17,6 +17,7 @@
 package org.jetbrains.kotlin.incremental
 
 import com.intellij.util.io.DataExternalizer
+import org.jetbrains.kotlin.build.GeneratedFile
 import org.jetbrains.kotlin.incremental.js.IncrementalResultsConsumerImpl
 import org.jetbrains.kotlin.incremental.js.IrTranslationResultValue
 import org.jetbrains.kotlin.incremental.js.TranslationResultValue
@@ -48,6 +49,7 @@ open class IncrementalJsCache(
         private const val INLINE_FUNCTIONS = "inline-functions"
         private const val HEADER_FILE_NAME = "header.meta"
         private const val PACKAGE_META_FILE = "packages-meta"
+        private const val SOURCE_TO_JS_OUTPUT = "source-to-js-output"
 
         fun hasHeaderFile(cachesDir: File) = File(cachesDir, HEADER_FILE_NAME).exists()
     }
@@ -60,6 +62,7 @@ open class IncrementalJsCache(
     private val irTranslationResults = registerMap(IrTranslationResultMap(IR_TRANSLATION_RESULT_MAP.storageFile, pathConverter))
     private val inlineFunctions = registerMap(InlineFunctionsMap(INLINE_FUNCTIONS.storageFile, pathConverter))
     private val packageMetadata = registerMap(PackageMetadataMap(PACKAGE_META_FILE.storageFile))
+    private val sourceToJsOutputsMap = registerMap(SourceToJsOutputMap(SOURCE_TO_JS_OUTPUT.storageFile, pathConverter))
 
     private val dirtySources = hashSetOf<File>()
 
@@ -75,6 +78,7 @@ open class IncrementalJsCache(
 
     override fun markDirty(removedAndCompiledSources: Collection<File>) {
         removedAndCompiledSources.forEach { sourceFile ->
+            sourceToJsOutputsMap.remove(sourceFile)
             // The common prefix of all FQN parents has to be the file package
             sourceToClassesMap[sourceFile].map { it.parentOrNull()?.asString() ?: "" }.minByOrNull { it.length }?.let {
                 packageMetadata.remove(it)
@@ -95,6 +99,10 @@ open class IncrementalJsCache(
         }
     }
 
+    fun getOutputsBySource(sourceFile: File): Collection<File> {
+        return sourceToJsOutputsMap.get(sourceFile)
+    }
+
     fun compareAndUpdate(incrementalResults: IncrementalResultsConsumerImpl, changesCollector: ChangesCollector) {
         val translatedFiles = incrementalResults.packageParts
 
@@ -175,6 +183,17 @@ open class IncrementalJsCache(
                 }
             }
         }
+
+    fun updateSourceToOutputMap(
+        generatedFiles: Iterable<GeneratedFile>,
+    ) {
+        for (generatedFile in generatedFiles) {
+            for (source in generatedFile.sourceFiles) {
+                if (dirtySources.contains(source))
+                    sourceToJsOutputsMap.add(source, generatedFile.outputFile)
+            }
+        }
+    }
 }
 
 private object TranslationResultValueExternalizer : DataExternalizer<TranslationResultValue> {

build-common/src/org/jetbrains/kotlin/incremental/storage/SourceToJsOutputMap.kt

@@ -0,0 +1,43 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.incremental.storage
+
+import org.jetbrains.kotlin.incremental.dumpCollection
+import java.io.File
+
+class SourceToJsOutputMap(storageFile: File, private val pathConverter: FileToPathConverter) : BasicStringMap<Collection<String>>(storageFile, StringCollectionExternalizer) {
+    override fun dumpValue(value: Collection<String>): String = value.dumpCollection()
+
+    @Synchronized
+    fun add(key: File, value: File) {
+        storage.append(pathConverter.toPath(key), listOf(pathConverter.toPath(value)))
+    }
+
+    operator fun get(sourceFile: File): Collection<File> =
+        storage[pathConverter.toPath(sourceFile)]?.map { pathConverter.toFile(it) } ?: setOf()
+
+
+    @Synchronized
+    operator fun set(key: File, values: Collection<File>) {
+        if (values.isEmpty()) {
+            remove(key)
+            return
+        }
+
+        storage[pathConverter.toPath(key)] = values.map { pathConverter.toPath(it) }
+    }
+
+    @Synchronized
+    fun remove(key: File) {
+        storage.remove(pathConverter.toPath(key))
+    }
+
+    @Synchronized
+    fun removeValues(key: File, removed: Set<File>) {
+        val notRemoved = this[key].filter { it !in removed }
+        this[key] = notRemoved
+    }
+}