[Gradle, JS] Refactor cacheBuilder to reuse one instance

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/targets/js/ir/KotlinJsIrLink.kt

@@ -99,15 +99,23 @@ abstract class KotlinJsIrLink @Inject constructor(
 
     override fun callCompilerAsync(args: K2JSCompilerArguments, sourceRoots: SourceRoots, changedFiles: ChangedFiles) {
         if (incrementalJsIr) {
-            val visitedDependencies = mutableSetOf<ResolvedDependency>()
-            val visitedFiles = mutableSetOf<File>()
             val visitedCompilations = mutableSetOf<KotlinCompilation<*>>()
             val allCacheDirectories = mutableSetOf<File>()
 
+            val cacheBuilder = CacheBuilder(
+                buildDir,
+                kotlinOptions,
+                libraryFilter,
+                compilerRunner,
+                { createCompilerArgs() },
+                { objects.fileCollection() },
+                computedCompilerClasspath,
+                logger,
+                reportingSettings
+            )
             val cacheArgs = visitAssociated(
                 compilation,
-                visitedDependencies,
+                cacheBuilder,
-                visitedFiles,
                 visitedCompilations,
                 allCacheDirectories
             )
@@ -121,44 +129,31 @@ abstract class KotlinJsIrLink @Inject constructor(
 
     private fun visitAssociated(
         associated: KotlinCompilation<*>,
-        visitedDependencies: MutableSet<ResolvedDependency>,
+        cacheBuilder: CacheBuilder,
-        visitedFiles: MutableSet<File>,
         visitedCompilations: MutableSet<KotlinCompilation<*>>,
         visitedCacheDirectories: MutableSet<File>
     ): List<File> {
         if (associated in visitedCompilations) return emptyList()
         visitedCompilations.add(associated)
 
-        val prevRes = associated.associateWith
+        val associatedCaches = associated.associateWith
             .flatMap { compilation ->
                 visitAssociated(
                     compilation,
-                    visitedDependencies,
+                    cacheBuilder,
-                    visitedFiles,
                     visitedCompilations,
                     visitedCacheDirectories
                 )
             }
 
-        return prevRes + CacheBuilder(
+        return cacheBuilder
-            buildDir,
+            .buildCompilerArgs(
-            project.configurations.getByName(associated.compileDependencyConfigurationName),
+                project.configurations.getByName(associated.compileDependencyConfigurationName),
-            associated.output.classesDirs,
+                associated.output.classesDirs,
-            kotlinOptions,
+                associatedCaches
-            libraryFilter,
+            )
-            compilerRunner,
+//            .filter { it !in visitedCacheDirectories }
-            { createCompilerArgs() },
+//            .also { visitedCacheDirectories.addAll(it) }
-            computedCompilerClasspath,
-            logger,
-            objects.fileCollection(),
-            reportingSettings,
-            visitedDependencies,
-            visitedFiles,
-            prevRes
-        )
-            .buildCompilerArgs()
-            .filter { it !in visitedCacheDirectories }
-            .also { visitedCacheDirectories.addAll(it) }
     }
 
     override fun setupCompilerArgs(args: K2JSCompilerArguments, defaultsOnly: Boolean, ignoreClasspathResolutionErrors: Boolean) {
@@ -182,25 +177,31 @@ abstract class KotlinJsIrLink @Inject constructor(
 
 internal class CacheBuilder(
     private val buildDir: File,
-    private val compileClasspath: Configuration,
-    private val additionalForResolve: FileCollection?,
     private val kotlinOptions: KotlinJsOptions,
     private val libraryFilter: (File) -> Boolean,
     private val compilerRunner: GradleCompilerRunner,
     private val compilerArgsFactory: () -> K2JSCompilerArguments,
+    private val objectFilesFactory: () -> FileCollection,
     private val computedCompilerClasspath: List<File>,
     private val logger: Logger,
-    private val outputFiles: FileCollection,
+    private val reportingSettings: ReportingSettings
-    private val reportingSettings: ReportingSettings,
-    private val visitedDependencies: MutableSet<ResolvedDependency>,
-    private val visitedFiles: MutableSet<File>,
-    private val associatedCaches: List<File>
 ) {
     val rootCacheDirectory by lazy {
         buildDir.resolve("klib/cache")
     }
 
-    fun buildCompilerArgs(): List<File> {
+    private val visitedDependencies = mutableSetOf<ResolvedDependency>()
+    private val visitedFiles = mutableSetOf<File>()
+    private val visitedCacheDirectories = mutableSetOf<File>()
+
+    private val objectFiles
+        get() = objectFilesFactory()
+
+    fun buildCompilerArgs(
+        compileClasspath: Configuration,
+        additionalForResolve: FileCollection?,
+        associatedCaches: List<File>
+    ): List<File> {
 
         val allCacheDirectories = mutableListOf<File>()
         val visitedDependenciesForCache = mutableSetOf<ResolvedDependency>()
@@ -208,9 +209,7 @@ internal class CacheBuilder(
         compileClasspath.resolvedConfiguration.firstLevelModuleDependencies
             .forEach { dependency ->
                 ensureDependencyCached(
-                    dependency,
+                    dependency
-                    visitedDependencies,
-                    visitedFiles
                 )
                 if (dependency !in visitedDependenciesForCache) {
                     (listOf(dependency) + getAllDependencies(dependency))
@@ -230,7 +229,6 @@ internal class CacheBuilder(
             cacheDirectory.mkdirs()
             runCompiler(
                 file,
-                visitedFiles,
                 compileClasspath.files,
                 cacheDirectory,
                 (allCacheDirectories + associatedCaches).distinct()
@@ -238,19 +236,19 @@ internal class CacheBuilder(
             allCacheDirectories.add(cacheDirectory)
         }
 
-        return allCacheDirectories
+        return associatedCaches + allCacheDirectories
+            .filter { it !in visitedCacheDirectories }
+            .also { visitedCacheDirectories.addAll(it) }
     }
 
     private fun ensureDependencyCached(
-        dependency: ResolvedDependency,
+        dependency: ResolvedDependency
-        visitedDependency: MutableSet<ResolvedDependency>,
-        visitedFiles: MutableSet<File>
     ) {
-        if (dependency in visitedDependency) return
+        if (dependency in visitedDependencies) return
-        visitedDependency.add(dependency)
+        visitedDependencies.add(dependency)
 
         dependency.children
-            .forEach { ensureDependencyCached(it, visitedDependency, visitedFiles) }
+            .forEach { ensureDependencyCached(it) }
 
         val artifactsToAddToCache = dependency.moduleArtifacts
             .filter { libraryFilter(it.file) }
@@ -268,7 +266,6 @@ internal class CacheBuilder(
         for (library in artifactsToAddToCache) {
             runCompiler(
                 library.file,
-                visitedFiles,
                 getAllDependencies(dependency)
                     .flatMap { it.moduleArtifacts }
                     .map { it.file },
@@ -280,7 +277,6 @@ internal class CacheBuilder(
 
     fun runCompiler(
         file: File,
-        visitedFiles: MutableSet<File>,
         dependencies: Collection<File>,
         cacheDirectory: File,
         dependenciesCacheDirectories: Collection<File>
@@ -315,7 +311,7 @@ internal class CacheBuilder(
             computedCompilerClasspath,
             messageCollector,
             outputItemCollector,
-            outputFiles = outputFiles,
+            outputFiles = objectFiles,
             reportingSettings = reportingSettings
         )