Always clear local state directories for non-incremental build

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/compilerRunner/GradleCompilerEnvironment.kt

@@ -14,6 +14,7 @@ internal class GradleCompilerEnvironment(
     val compilerClasspath: List<File>,
     messageCollector: GradleMessageCollector,
     outputItemsCollector: OutputItemsCollector,
+    val localStateDirectories: List<File>,
     val incrementalCompilationEnvironment: IncrementalCompilationEnvironment? = null
 ) : CompilerEnvironment(Services.EMPTY, messageCollector, outputItemsCollector) {
     val toolsJar: File? by lazy { findToolsJar() }

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/compilerRunner/GradleKotlinCompilerRunner.kt

@@ -134,7 +134,8 @@ internal open class GradleCompilerRunner(protected val project: Project) {
             isVerbose = compilerArgs.verbose,
             incrementalCompilationEnvironment = incrementalCompilationEnvironment,
             incrementalModuleInfo = modulesInfo,
-            buildFile = buildFile
+            buildFile = buildFile,
+            localStateDirectories = environment.localStateDirectories
         )
         runCompilerAsync(workArgs)
     }

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/compilerRunner/GradleKotlinCompilerWork.kt

@@ -14,8 +14,8 @@ import org.jetbrains.kotlin.cli.common.messages.MessageRenderer
 import org.jetbrains.kotlin.config.Services
 import org.jetbrains.kotlin.daemon.common.*
 import org.jetbrains.kotlin.gradle.plugin.kotlinDebug
-import org.jetbrains.kotlin.gradle.plugin.kotlinInfo
 import org.jetbrains.kotlin.gradle.tasks.GradleMessageCollector
+import org.jetbrains.kotlin.gradle.tasks.clearLocalStateDirectories
 import org.jetbrains.kotlin.gradle.tasks.throwGradleExceptionIfError
 import org.jetbrains.kotlin.incremental.ChangedFiles
 import org.jetbrains.kotlin.incremental.DELETE_MODULE_FILE_PROPERTY
@@ -52,7 +52,8 @@ internal class GradleKotlinCompilerWorkArguments(
     val isVerbose: Boolean,
     val incrementalCompilationEnvironment: IncrementalCompilationEnvironment?,
     val incrementalModuleInfo: IncrementalModuleInfo?,
-    val buildFile: File?
+    val buildFile: File?,
+    val localStateDirectories: List<File>
 ) : Serializable {
     companion object {
         const val serialVersionUID: Long = 0
@@ -79,6 +80,7 @@ internal class GradleKotlinCompilerWork @Inject constructor(
     private val incrementalCompilationEnvironment = config.incrementalCompilationEnvironment
     private val incrementalModuleInfo = config.incrementalModuleInfo
     private val buildFile = config.buildFile
+    private val localStateDirectories = config.localStateDirectories
 
     private val log: KotlinLogger =
         SL4JKotlinLogger(LoggerFactory.getLogger("GradleKotlinCompilerWork"))
@@ -88,8 +90,15 @@ internal class GradleKotlinCompilerWork @Inject constructor(
         get() = incrementalCompilationEnvironment != null
 
     override fun run() {
+        if (!isIncremental) {
+            clearLocalStateDirectories(log, localStateDirectories, "IC is disabled")
+        }
+
         val exitCode = try {
             compileWithDaemonOrFallbackImpl()
+        } catch (e: Throwable) {
+            clearLocalStateDirectories(log, localStateDirectories, "exception when running compiler")
+            throw e
         } finally {
             if (buildFile != null && System.getProperty(DELETE_MODULE_FILE_PROPERTY) != "false") {
                 buildFile.delete()
@@ -102,28 +111,13 @@ internal class GradleKotlinCompilerWork @Inject constructor(
             }
 
             if (exitCode != ExitCode.OK) {
-                // for non-incremental compilation cleanup is always performed before compiler is called
+                clearLocalStateDirectories(log, localStateDirectories, "exit code: $exitCode")
-                cleanupOnError(incrementalCompilationEnvironment)
             }
         }
 
         throwGradleExceptionIfError(exitCode)
     }
 
-    private fun cleanupOnError(incrementalCompilationEnvironment: IncrementalCompilationEnvironment) {
-        val localStateDirs = incrementalCompilationEnvironment.localStateDirs
-        log.info("Deleting output directories on error: ${localStateDirs.joinToString()}")
-        for (dir in localStateDirs) {
-            if (dir.exists()) {
-                if (dir.deleteRecursively()) {
-                    log.debug("Deleted $dir")
-                } else {
-                    log.debug("Could not delete $dir")
-                }
-            }
-        }
-    }
-
     private fun compileWithDaemonOrFallbackImpl(): ExitCode {
         with(log) {
             kotlinDebug { "Kotlin compiler class: ${compilerClassName}" }
@@ -240,7 +234,7 @@ internal class GradleKotlinCompilerWork @Inject constructor(
             compilerMode = CompilerMode.INCREMENTAL_COMPILER,
             targetPlatform = targetPlatform,
             usePreciseJavaTracking = icEnv.usePreciseJavaTracking,
-            localStateDirs = icEnv.localStateDirs,
+            localStateDirs = localStateDirectories,
             multiModuleICSettings = icEnv.multiModuleICSettings,
             modulesInfo = incrementalModuleInfo!!
         )

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/compilerRunner/IncrementalCompilationEnvironment.kt

@@ -14,7 +14,6 @@ internal class IncrementalCompilationEnvironment(
     val changedFiles: ChangedFiles,
     val workingDir: File,
     val usePreciseJavaTracking: Boolean = false,
-    val localStateDirs: List<File> = emptyList(),
     val disableMultiModuleIC: Boolean = false,
     val multiModuleICSettings: MultiModuleICSettings
 ) : Serializable {

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/internal/kapt/KaptWithKotlincTask.kt

@@ -20,7 +20,7 @@ import org.jetbrains.kotlin.compilerRunner.OutputItemsCollectorImpl
 import org.jetbrains.kotlin.gradle.plugin.PLUGIN_CLASSPATH_CONFIGURATION_NAME
 import org.jetbrains.kotlin.gradle.tasks.CompilerPluginOptions
 import org.jetbrains.kotlin.gradle.tasks.GradleMessageCollector
-import org.jetbrains.kotlin.gradle.tasks.clearOutputDirectories
+import org.jetbrains.kotlin.gradle.tasks.localStateDirectories
 import org.jetbrains.kotlin.gradle.utils.toSortedPathsArray
 
 open class KaptWithKotlincTask : KaptTask(), CompilerArgumentAwareWithInput<K2JVMCompilerArguments> {
@@ -55,15 +55,14 @@ open class KaptWithKotlincTask : KaptTask(), CompilerArgumentAwareWithInput<K2JV
     fun compile() {
         logger.debug("Running kapt annotation processing using the Kotlin compiler")
 
-        /** Delete everything inside generated sources and classes output directory
-         * (annotation processing is not incremental) */
-        clearOutputDirectories()
-
         val args = prepareCompilerArguments()
 
         val messageCollector = GradleMessageCollector(GradleKotlinLogger(logger))
         val outputItemCollector = OutputItemsCollectorImpl()
-        val environment = GradleCompilerEnvironment(compilerClasspath, messageCollector, outputItemCollector)
+        val environment = GradleCompilerEnvironment(
+            compilerClasspath, messageCollector, outputItemCollector,
+            localStateDirectories = localStateDirectories()
+        )
         if (environment.toolsJar == null && !isAtLeastJava9) {
             throw GradleException("Could not find tools.jar in system classpath, which is required for kapt to work")
         }

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/internal/kapt/KaptWithoutKotlincTask.kt

@@ -13,7 +13,7 @@ import org.gradle.workers.IsolationMode
 import org.gradle.workers.WorkerExecutor
 import org.jetbrains.kotlin.gradle.internal.Kapt3KotlinGradleSubplugin.Companion.KAPT_WORKER_DEPENDENCIES_CONFIGURATION_NAME
 import org.jetbrains.kotlin.gradle.plugin.KotlinAndroidPluginWrapper
-import org.jetbrains.kotlin.gradle.tasks.clearOutputDirectories
+import org.jetbrains.kotlin.gradle.tasks.clearLocalStateDirectories
 import org.jetbrains.kotlin.gradle.tasks.findKotlinStdlibClasspath
 import org.jetbrains.kotlin.gradle.tasks.findToolsJar
 import org.jetbrains.kotlin.utils.PathUtil
@@ -48,7 +48,7 @@ open class KaptWithoutKotlincTask @Inject constructor(private val workerExecutor
     fun compile() {
         logger.info("Running kapt annotation processing using the Gradle Worker API")
 
-        clearOutputDirectories()
+        clearLocalStateDirectories()
 
         val compileClasspath = classpath.files.toMutableList()
         if (project.plugins.none { it is KotlinAndroidPluginWrapper }) {

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/tasks/KotlinCompileCommon.kt

@@ -67,7 +67,10 @@ internal open class KotlinCompileCommon : AbstractKotlinCompile<K2MetadataCompil
         val messageCollector = GradleMessageCollector(logger)
         val outputItemCollector = OutputItemsCollectorImpl()
         val compilerRunner = compilerRunner()
-        val environment = GradleCompilerEnvironment(computedCompilerClasspath, messageCollector, outputItemCollector)
+        val environment = GradleCompilerEnvironment(
+            computedCompilerClasspath, messageCollector, outputItemCollector,
+            localStateDirectories = localStateDirectories()
+        )
         compilerRunner.runMetadataCompilerAsync(sourceRoots.kotlinSourceFiles, args, environment)
     }
 }

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/tasks/Tasks.kt

@@ -397,16 +397,16 @@ open class KotlinCompile : AbstractKotlinCompile<K2JVMCompilerArguments>(), Kotl
                 if (hasFilesInTaskBuildDirectory()) changedFiles else ChangedFiles.Unknown(),
                 taskBuildDirectory,
                 usePreciseJavaTracking = usePreciseJavaTracking,
-                localStateDirs = outputDirectories,
                 disableMultiModuleIC = disableMultiModuleIC(),
                 multiModuleICSettings = multiModuleICSettings
             )
-        } else {
+        } else null
-            clearOutputDirectories(reason = "IC is disabled for the task")
-            null
-        }
 
-        val environment = GradleCompilerEnvironment(computedCompilerClasspath, messageCollector, outputItemCollector, icEnv)
+        val environment = GradleCompilerEnvironment(
+            computedCompilerClasspath, messageCollector, outputItemCollector,
+            localStateDirectories = localStateDirectories(),
+            incrementalCompilationEnvironment = icEnv
+        )
         compilerRunner.runJvmCompilerAsync(
             sourceRoots.kotlinSourceFiles,
             commonSourceSet.toList(),
@@ -554,7 +554,11 @@ open class Kotlin2JsCompile() : AbstractKotlinCompile<K2JSCompilerArguments>(),
             )
         } else null
 
-        val environment = GradleCompilerEnvironment(computedCompilerClasspath, messageCollector, outputItemCollector, icEnv)
+        val environment = GradleCompilerEnvironment(
+            computedCompilerClasspath, messageCollector, outputItemCollector,
+            localStateDirectories = localStateDirectories(),
+            incrementalCompilationEnvironment = icEnv
+        )
         compilerRunner.runJsCompilerAsync(sourceRoots.kotlinSourceFiles, commonSourceSet.toList(), args, environment)
     }
 }

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/tasks/tasksUtils.kt

@@ -3,6 +3,8 @@ package org.jetbrains.kotlin.gradle.tasks
 import org.gradle.api.GradleException
 import org.gradle.api.Task
 import org.jetbrains.kotlin.cli.common.ExitCode
+import org.jetbrains.kotlin.compilerRunner.GradleKotlinLogger
+import org.jetbrains.kotlin.compilerRunner.KotlinLogger
 import org.jetbrains.kotlin.gradle.plugin.kotlinDebug
 import org.jetbrains.kotlin.gradle.utils.outputsCompatible
 import java.io.File
@@ -18,23 +20,27 @@ fun throwGradleExceptionIfError(exitCode: ExitCode) {
     }
 }
 
-internal val <T : Task> T.outputDirectories: List<File>
+internal fun <T : Task> T.localStateDirectories(): List<File> =
-    get() = outputsCompatible.files.files.filter { it.isDirectory }
+    outputsCompatible.files.files.filter { it.isDirectory }
 
-internal fun <T : Task> T.clearOutputDirectories(reason: String? = null) {
+internal fun <T : Task> T.clearLocalStateDirectories(reason: String? = null) {
-    logger.kotlinDebug {
+    clearLocalStateDirectories(GradleKotlinLogger(logger), localStateDirectories(), reason)
+}
+
+internal fun clearLocalStateDirectories(log: KotlinLogger, localStateDirectories: List<File>, reason: String?) {
+    log.kotlinDebug {
         val suffix = reason?.let { " ($it)" }.orEmpty()
-        "Clearing output directories for task '$path'$suffix:"
+        "Clearing output directories$suffix:"
     }
-    val outputDirectories = outputDirectories
+    for (dir in localStateDirectories) {
-    for (dir in outputDirectories) {
+        if (!dir.exists()) continue
         when {
             dir.isDirectory -> {
                 dir.deleteRecursively()
                 dir.mkdirs()
-                logger.kotlinDebug { "  deleted $dir" }
+                log.kotlinDebug { "  deleted $dir" }
             }
-            else -> logger.kotlinDebug { "  skipping $dir (not a directory)" }
+            else -> log.kotlinDebug { "  skipping $dir (not a directory)" }
         }
     }
 }