[IC] Always mark as dirty files referenced by frontend plugins

^KT-55982 Fixed
^KT-75864

Author: demiurg906

build-common/src/org/jetbrains/kotlin/compilerRunner/OutputItemsCollector.kt

@@ -22,6 +22,8 @@ import java.io.File
 
 interface OutputItemsCollector {
     fun add(sourceFiles: Collection<File>, outputFile: File)
+    fun addSourceReferencedByCompilerPlugin(sourceFile: File)
+    fun addOutputFileGeneratedForPlugin(outputFile: File)
 }
 
 class OutputItemsCollectorImpl : OutputItemsCollector {
@@ -30,9 +32,27 @@ class OutputItemsCollectorImpl : OutputItemsCollector {
 
     private val _outputs: MutableList<SimpleOutputItem> = mutableListOf()
 
+    val sourcesReferencedByCompilerPlugin: List<File>
+        get() = _sourcesReferencedByCompilerPlugin
+
+    private val _sourcesReferencedByCompilerPlugin: MutableList<File> = mutableListOf()
+
+    val outputsFileGeneratedForPlugin: List<File>
+        get() = _outputsFileGeneratedForPlugin
+
+    private val _outputsFileGeneratedForPlugin: MutableList<File> = mutableListOf()
+
     override fun add(sourceFiles: Collection<File>, outputFile: File) {
         _outputs.add(SimpleOutputItem(sourceFiles, outputFile))
     }
+
+    override fun addSourceReferencedByCompilerPlugin(sourceFile: File) {
+        _sourcesReferencedByCompilerPlugin.add(sourceFile)
+    }
+
+    override fun addOutputFileGeneratedForPlugin(outputFile: File) {
+        _outputsFileGeneratedForPlugin.add(outputFile)
+    }
 }
 
 data class SimpleOutputItem(val sourceFiles: Collection<File>, val outputFile: File) {

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

@@ -279,4 +279,13 @@ class TransactionOutputsRegistrar(
         transaction.registerAddedOrChangedFile(outputFile.toPath())
         origin.add(sourceFiles, outputFile)
     }
-}
+
+    override fun addSourceReferencedByCompilerPlugin(sourceFile: File) {
+        origin.addSourceReferencedByCompilerPlugin(sourceFile)
+    }
+
+    override fun addOutputFileGeneratedForPlugin(outputFile: File) {
+        transaction.registerAddedOrChangedFile(outputFile.toPath())
+        origin.addOutputFileGeneratedForPlugin(outputFile)
+    }
+}

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

@@ -15,10 +15,10 @@ class ICFileMappingTrackerImpl(private val outputItemsCollector: OutputItemsColl
     }
 
     override fun recordSourceReferencedByCompilerPlugin(sourceFile: File) {
-        // nothing yet
+        outputItemsCollector.addSourceReferencedByCompilerPlugin(sourceFile)
     }
 
     override fun recordOutputFileGeneratedForPlugin(outputFile: File) {
-        // nothing yet
+        outputItemsCollector.addOutputFileGeneratedForPlugin(outputFile)
     }
 }

build-common/test/org/jetbrains/kotlin/incremental/TransactionOutputsRegistrarTest.kt

@@ -27,6 +27,10 @@ class TransactionOutputsRegistrarTest {
         override fun add(sourceFiles: Collection<File>, outputFile: File) {
             addedOutputItems.add(sourceFiles to outputFile)
         }
+
+        override fun addSourceReferencedByCompilerPlugin(sourceFile: File) {}
+
+        override fun addOutputFileGeneratedForPlugin(outputFile: File) {}
     }
 
     @Test
@@ -65,4 +69,4 @@ class TransactionOutputsRegistrarTest {
         )
         assertFalse(Files.exists(outputFile), "Output file wasn't reverted")
     }
-}
+}

compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/CompilerPluginFilesCache.kt

@@ -0,0 +1,86 @@
+/*
+ * Copyright 2010-2025 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
+
+import com.intellij.util.io.KeyDescriptor
+import org.jetbrains.kotlin.build.report.debug
+import org.jetbrains.kotlin.incremental.storage.AbstractBasicMap
+import org.jetbrains.kotlin.incremental.storage.BasicMapsOwner
+import org.jetbrains.kotlin.incremental.storage.IntExternalizer
+import org.jetbrains.kotlin.incremental.storage.ListExternalizer
+import org.jetbrains.kotlin.incremental.storage.toDescriptor
+import java.io.DataInput
+import java.io.DataOutput
+import java.io.File
+
+class CompilerPluginFilesCache(
+    workingDir: File,
+    private val icContext: IncrementalCompilationContext,
+) : BasicMapsOwner(workingDir) {
+    companion object {
+        private const val SOURCES_REFERENCED_BY_PLUGINS = "sources-referenced-by-plugins"
+        private const val OUTPUTS_GENERATED_FOR_PLUGINS = "outputs-generated-for-plugins"
+    }
+
+    private val sourceFilesReferencedByPlugins: ListLikeMap = registerMap(
+        ListLikeMap(
+            storageFile = SOURCES_REFERENCED_BY_PLUGINS.storageFile,
+            fileDescriptor = icContext.fileDescriptorForSourceFiles,
+            icContext = icContext
+        )
+    )
+
+    private val outputFilesGeneratedForPlugins: ListLikeMap = registerMap(
+        ListLikeMap(
+            storageFile = OUTPUTS_GENERATED_FOR_PLUGINS.storageFile,
+            fileDescriptor = icContext.fileDescriptorForOutputFiles,
+            icContext = icContext
+        )
+    )
+
+    fun getSourceFilesReferencedByPlugins(): List<File> {
+        return sourceFilesReferencedByPlugins.getValue()
+    }
+
+    fun recordSourceFilesReferencedByPlugins(files: List<File>) {
+        sourceFilesReferencedByPlugins.setValue(files)
+    }
+
+    fun recordOutputFilesGeneratedByPlugins(files: List<File>) {
+        outputFilesGeneratedForPlugins.setValue(files)
+    }
+
+    fun removeOutputsGeneratedByPlugins() {
+        val value = outputFilesGeneratedForPlugins.getAndRemoveValue()
+        value.forEach {
+            icContext.reporter.debug { "Deleting $it on clearing cache for plugin outputs" }
+            icContext.transaction.deleteFile(it.toPath())
+        }
+    }
+}
+
+private class ListLikeMap(
+    storageFile: File,
+    fileDescriptor: KeyDescriptor<File>,
+    icContext: IncrementalCompilationContext,
+) : AbstractBasicMap<Int, List<File>>(
+    storageFile,
+    keyDescriptor = IntExternalizer.toDescriptor(),
+    valueExternalizer = ListExternalizer(fileDescriptor),
+    icContext,
+) {
+    fun getValue(): List<File> {
+        return get(0).orEmpty()
+    }
+
+    fun getAndRemoveValue(): List<File> {
+        return getValue().also { remove(0) }
+    }
+
+    fun setValue(value: List<File>) {
+        set(0, value)
+    }
+}

compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalCachesManager.kt

@@ -38,9 +38,11 @@ abstract class IncrementalCachesManager<PlatformCache : AbstractIncrementalCache
 
     private val inputSnapshotsCacheDir = File(cachesRootDir, "inputs").apply { mkdirs() }
     private val lookupCacheDir = File(cachesRootDir, "lookups").apply { mkdirs() }
+    private val compilerPluginFilesCacheDir = File(cachesRootDir, "compilerPluginFiles").apply { mkdirs() }
 
     val inputsCache: InputsCache = InputsCache(inputSnapshotsCacheDir, icContext).apply { registerCache() }
     val lookupCache: LookupStorage = LookupStorage(lookupCacheDir, icContext).apply { registerCache() }
+    val compilerPluginFilesCache: CompilerPluginFilesCache = CompilerPluginFilesCache(compilerPluginFilesCacheDir, icContext).apply { registerCache() }
     abstract val platformCache: PlatformCache
 
     @Suppress("UnstableApiUsage")
@@ -75,4 +77,4 @@ class IncrementalJsCachesManager(
 ) : IncrementalCachesManager<IncrementalJsCache>(icContext, cachesRootDir) {
     private val jsCacheFile = File(cachesRootDir, "js").apply { mkdirs() }
     override val platformCache = IncrementalJsCache(jsCacheFile, icContext, serializerProtocol).apply { registerCache() }
-}
+}

compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalCompilerRunner.kt

@@ -472,8 +472,10 @@ abstract class IncrementalCompilerRunner<
         while (dirtySources.any() || runWithNoDirtyKotlinSources(caches)) {
             val complementaryFiles = caches.platformCache.getComplementaryFilesRecursive(dirtySources)
             dirtySources.addAll(complementaryFiles)
+            dirtySources.addAll(caches.compilerPluginFilesCache.getSourceFilesReferencedByPlugins())
             caches.platformCache.markDirty(dirtySources)
             caches.inputsCache.removeOutputForSourceFiles(dirtySources)
+            caches.compilerPluginFilesCache.removeOutputsGeneratedByPlugins()
 
             val lookupTracker = LookupTrackerImpl(getLookupTrackerDelegate())
             val expectActualTracker = ExpectActualTrackerImpl()
@@ -546,6 +548,10 @@ abstract class IncrementalCompilerRunner<
                 caches.platformCache.updateComplementaryFiles(dirtySources, expectActualTracker)
                 caches.inputsCache.registerOutputForSourceFiles(generatedFiles)
                 caches.lookupCache.update(lookupTracker, sourcesToCompile, removedKotlinSources)
+                caches.compilerPluginFilesCache.let {
+                    it.recordSourceFilesReferencedByPlugins(outputItemsCollector.sourcesReferencedByCompilerPlugin)
+                    it.recordOutputFilesGeneratedByPlugins(outputItemsCollector.outputsFileGeneratedForPlugin)
+                }
                 updateCaches(services, caches, generatedFiles, changesCollector)
             }
             if (compilationMode is CompilationMode.Rebuild) {

plugins/plugin-sandbox/plugin-sandbox-ic-test/build.gradle.kts

@@ -15,6 +15,7 @@ dependencies {
 
     testRuntimeOnly(project(":core:descriptors.runtime"))
     testRuntimeOnly(project(":compiler:fir:fir-serialization"))
+    testRuntimeOnly(project(":compiler:fir:plugin-utils"))
 
     testRuntimeOnly(commonDependency("org.lz4:lz4-java"))
     testRuntimeOnly(commonDependency("org.jetbrains.intellij.deps.jna:jna"))

plugins/plugin-sandbox/plugin-sandbox-ic-test/testData/pureKotlin/addMethodToGeneratedClass/A.kt

@@ -5,5 +5,3 @@ import org.jetbrains.kotlin.plugin.sandbox.ExternalClassWithNested
 
 @ExternalClassWithNested
 class A
-
-FAIL // comment me to actually run test

plugins/plugin-sandbox/plugin-sandbox-ic-test/testData/pureKotlin/addMethodToGeneratedClass/build.log

@@ -1,6 +1,7 @@
 ================ Step #1 =================
 
 Compiling files:
+  src/A.kt
   src/B.kt
 End of files
 Exit code: OK