[K/N][caches] Removed old slow and hacky version of per-file caches building

compiler/cli/cli-common/src/org/jetbrains/kotlin/cli/common/arguments/K2NativeCompilerArguments.kt

@@ -224,9 +224,6 @@ class K2NativeCompilerArguments : CommonCompilerArguments() {
     @Argument(value = "-Xmake-per-file-cache", description = "Force compiler to produce per-file cache")
     var makePerFileCache: Boolean = false
 
-    @Argument(value = "-Xbatched-per-file-cache-build", valueDescription = "{disable|enable}", description = "Build per-file cache in one batch")
-    var batchedPerFileCacheBuild: String? = null
-
     @Argument(value = "-Xexport-kdoc", description = "Export KDoc in framework header")
     var exportKDoc: Boolean = false
 

kotlin-native/backend.native/cli.bc/src/org/jetbrains/kotlin/cli/bc/K2Native.kt

@@ -286,19 +286,8 @@ class K2Native : CLICompiler<K2NativeCompilerArguments>() {
                 put(CACHE_DIRECTORIES, cacheDirectories)
                 put(CACHED_LIBRARIES, parseCachedLibraries(arguments, configuration))
                 val filesToCache = arguments.filesToCache
-                if (outputKind == CompilerOutputKind.PRELIMINARY_CACHE && filesToCache.isNullOrEmpty())
-                    configuration.report(ERROR, "preliminary_cache only supported for per-file caches")
                 filesToCache?.let { put(FILES_TO_CACHE, it.toList()) }
                 put(MAKE_PER_FILE_CACHE, arguments.makePerFileCache)
-                putIfNotNull(BATCHED_PER_FILE_CACHE_BUILD, when (arguments.batchedPerFileCacheBuild) {
-                    null -> null
-                    "enable" -> true
-                    "disable" -> false
-                    else -> {
-                        configuration.report(ERROR, "Expected 'enable' or 'disable' for batchedPerFileCacheBuild")
-                        false
-                    }
-                })
 
                 parseShortModuleName(arguments, configuration, outputKind)?.let {
                     put(SHORT_MODULE_NAME, it)

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/CacheSupport.kt

@@ -72,7 +72,7 @@ class CacheSupport(
                         ?: configuration.reportCompilationError("cache directory $it is not found or not a directory")
             }
 
-    internal fun tryGetImplicitOutput(explicitlyProducePerFileCache: Boolean): String? {
+    internal fun tryGetImplicitOutput(): String? {
         val libraryToCache = libraryToCache ?: return null
         // Put the resulting library in the first cache directory.
         val cacheDirectory = implicitCacheDirectories.firstOrNull() ?: return null
@@ -86,14 +86,8 @@ class CacheSupport(
         val singleFilePath = singleFileStrategy?.filePath
                 ?: return baseLibraryCacheDirectory.absolutePath
 
-        val fqName = singleFileStrategy.fqName
-        val fileCacheDirectory = baseLibraryCacheDirectory.child(cacheFileId(fqName, singleFilePath))
-        if (!explicitlyProducePerFileCache)
-            return fileCacheDirectory.absolutePath
-        val contentDirName = if (produce == CompilerOutputKind.PRELIMINARY_CACHE)
-            CachedLibraries.PER_FILE_CACHE_IR_LEVEL_DIR_NAME
-        else CachedLibraries.PER_FILE_CACHE_BINARY_LEVEL_DIR_NAME
-        return fileCacheDirectory.child(contentDirName).absolutePath
+        val fileCacheDirectory = baseLibraryCacheDirectory.child(cacheFileId(singleFileStrategy.fqName, singleFilePath))
+        return fileCacheDirectory.absolutePath
     }
 
     internal val cachedLibraries: CachedLibraries = run {
@@ -148,10 +142,7 @@ class CacheSupport(
                     val fileReader = IrLibraryFileFromBytes(IrKlibBytesSource(libraryToAddToCache, index))
                     fileReader.deserializeFqName(fileProtos[index].fqNameList)
                 }
-                if (configuration.get(KonanConfigKeys.BATCHED_PER_FILE_CACHE_BUILD) == false)
-                    CacheDeserializationStrategy.SingleFile(filesToCache.single(), fqNames.single())
-                else
-                    CacheDeserializationStrategy.MultipleFiles(filesToCache, fqNames)
+                CacheDeserializationStrategy.MultipleFiles(filesToCache, fqNames)
             }
             PartialCacheInfo(libraryToAddToCache, strategy)
         }

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/CompilerOutput.kt

@@ -31,9 +31,10 @@ import org.jetbrains.kotlin.utils.addToStdlib.ifNotEmpty
 val KonanConfig.isFinalBinary: Boolean get() = when (this.produce) {
     CompilerOutputKind.PROGRAM, CompilerOutputKind.DYNAMIC,
     CompilerOutputKind.STATIC -> true
-    CompilerOutputKind.DYNAMIC_CACHE, CompilerOutputKind.STATIC_CACHE, CompilerOutputKind.PRELIMINARY_CACHE,
+    CompilerOutputKind.DYNAMIC_CACHE, CompilerOutputKind.STATIC_CACHE,
     CompilerOutputKind.LIBRARY, CompilerOutputKind.BITCODE -> false
     CompilerOutputKind.FRAMEWORK -> !omitFrameworkBinary
+    else -> error("not supported: ${this.produce}")
 }
 
 val CompilerOutputKind.isNativeLibrary: Boolean
@@ -62,16 +63,16 @@ val KonanConfig.involvesLinkStage: Boolean
         CompilerOutputKind.PROGRAM, CompilerOutputKind.DYNAMIC,
         CompilerOutputKind.DYNAMIC_CACHE, CompilerOutputKind.STATIC_CACHE,
         CompilerOutputKind.STATIC -> true
-        CompilerOutputKind.LIBRARY, CompilerOutputKind.BITCODE, CompilerOutputKind.PRELIMINARY_CACHE -> false
+        CompilerOutputKind.LIBRARY, CompilerOutputKind.BITCODE -> false
         CompilerOutputKind.FRAMEWORK -> !omitFrameworkBinary
+        else -> error("not supported: ${this.produce}")
     }
 
 val CompilerOutputKind.isCache: Boolean
     get() = this == CompilerOutputKind.STATIC_CACHE || this == CompilerOutputKind.DYNAMIC_CACHE
-            || this == CompilerOutputKind.PRELIMINARY_CACHE
 
 val KonanConfig.involvesCodegen: Boolean
-    get() = produce != CompilerOutputKind.LIBRARY && produce != CompilerOutputKind.PRELIMINARY_CACHE && !omitFrameworkBinary
+    get() = produce != CompilerOutputKind.LIBRARY && !omitFrameworkBinary
 
 internal fun llvmIrDumpCallback(state: ActionState, module: IrModuleFragment, context: Context) {
     module.let{}
@@ -274,7 +275,7 @@ internal fun produceOutput(context: Context) {
             context.bitcodeFileName = output
             LLVMWriteBitcodeToFile(context.generationState.llvm.module, output)
         }
-        CompilerOutputKind.PRELIMINARY_CACHE -> {}
+        else -> error("not supported: $produce")
     }
 }
 

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/KonanConfig.kt

@@ -17,14 +17,12 @@ import org.jetbrains.kotlin.descriptors.ModuleDescriptor
 import org.jetbrains.kotlin.konan.CURRENT
 import org.jetbrains.kotlin.konan.CompilerVersion
 import org.jetbrains.kotlin.konan.MetaVersion
-import org.jetbrains.kotlin.konan.TempFiles
 import org.jetbrains.kotlin.konan.file.File
 import org.jetbrains.kotlin.konan.library.KonanLibrary
 import org.jetbrains.kotlin.konan.properties.loadProperties
 import org.jetbrains.kotlin.konan.target.*
 import org.jetbrains.kotlin.konan.util.KonanHomeProvider
 import org.jetbrains.kotlin.konan.util.visibleName
-import org.jetbrains.kotlin.library.KotlinLibrary
 import org.jetbrains.kotlin.library.resolver.TopologicalLibraryOrder
 import org.jetbrains.kotlin.util.removeSuffixIfPresent
 import org.jetbrains.kotlin.utils.addToStdlib.cast
@@ -409,17 +407,13 @@ class KonanConfig(val project: Project, val configuration: CompilerConfiguration
         get() = cacheSupport.libraryToCache
 
     internal val producePerFileCache
-        get() = libraryToCache?.strategy is CacheDeserializationStrategy.SingleFile
-
-    internal val produceBatchedPerFileCache
         get() = configuration.get(KonanConfigKeys.MAKE_PER_FILE_CACHE) == true
-                && configuration.get(KonanConfigKeys.BATCHED_PER_FILE_CACHE_BUILD) != false
 
     val outputPath get() = configuration.get(KonanConfigKeys.OUTPUT)?.removeSuffixIfPresent(produce.suffix(target)) ?: produce.visibleName
 
     private val implicitModuleName: String
         get() = cacheSupport.libraryToCache?.let {
-            if (configuration.get(KonanConfigKeys.MAKE_PER_FILE_CACHE) == true)
+            if (producePerFileCache)
                 CachedLibraries.getPerFileCachedLibraryName(it.klib)
             else
                 CachedLibraries.getCachedLibraryName(it.klib)

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/KonanConfigurationKeys.kt

@@ -48,8 +48,6 @@ class KonanConfigKeys {
                 = CompilerConfigurationKey.create<List<String>>("which files should be compiled to cache")
         val MAKE_PER_FILE_CACHE: CompilerConfigurationKey<Boolean>
                 = CompilerConfigurationKey.create<Boolean>("make per-file cache")
-        val BATCHED_PER_FILE_CACHE_BUILD: CompilerConfigurationKey<Boolean>
-                = CompilerConfigurationKey.create<Boolean>("build per-file caches in batches")
         val FRAMEWORK_IMPORT_HEADERS: CompilerConfigurationKey<List<String>>
                 = CompilerConfigurationKey.create<List<String>>("headers imported to framework header")
         val FRIEND_MODULES: CompilerConfigurationKey<List<String>>

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/KonanDriver.kt

@@ -38,28 +38,12 @@ class KonanDriver(val project: Project, val environment: KotlinCoreEnvironment,
                 }
             }
         }
-
-        if (fileNames == null) {
-            KonanConfig(project, configuration).runTopLevelPhases()
-        } else {
+        if (fileNames != null) {
             configuration.put(KonanConfigKeys.MAKE_PER_FILE_CACHE, true)
-            if (configuration.get(KonanConfigKeys.BATCHED_PER_FILE_CACHE_BUILD) == false) {
-                fileNames.forEach { buildFileCache(it, CompilerOutputKind.PRELIMINARY_CACHE) }
-                fileNames.forEach { buildFileCache(it, configuration.get(KonanConfigKeys.PRODUCE)!!) }
-            } else {
-                configuration.put(KonanConfigKeys.FILES_TO_CACHE, fileNames)
-                KonanConfig(project, configuration).runTopLevelPhases()
-            }
+            configuration.put(KonanConfigKeys.FILES_TO_CACHE, fileNames)
         }
-    }
 
-    private fun buildFileCache(fileName: String, cacheKind: CompilerOutputKind) {
-        val phaseConfig = configuration.get(CLIConfigurationKeys.PHASE_CONFIG)!!
-        val subConfiguration = configuration.copy()
-        subConfiguration.put(KonanConfigKeys.PRODUCE, cacheKind)
-        subConfiguration.put(KonanConfigKeys.FILES_TO_CACHE, listOf(fileName))
-        subConfiguration.put(CLIConfigurationKeys.PHASE_CONFIG, phaseConfig.toBuilder().build())
-        KonanConfig(project, subConfiguration).runTopLevelPhases()
+        KonanConfig(project, configuration).runTopLevelPhases()
     }
 
     private fun KonanConfig.runTopLevelPhases() {

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/Linker.kt

@@ -35,7 +35,6 @@ internal fun determineLinkerOutput(context: Context): LinkerOutputKind =
         }
 
 internal class CacheStorage(val context: Context) {
-    private val isPreliminaryCache = context.config.produce == CompilerOutputKind.PRELIMINARY_CACHE
     private val outputFiles = context.generationState.outputFiles
 
     fun renameOutput() {
@@ -49,12 +48,9 @@ internal class CacheStorage(val context: Context) {
 
     fun saveAdditionalCacheInfo() {
         outputFiles.prepareTempDirectories()
-        if (!isPreliminaryCache)
-            saveCacheBitcodeDependencies()
-        if (isPreliminaryCache || !context.config.producePerFileCache || context.config.produceBatchedPerFileCache) {
-            saveInlineFunctionBodies()
-            saveClassFields()
-        }
+        saveCacheBitcodeDependencies()
+        saveInlineFunctionBodies()
+        saveClassFields()
     }
 
     private fun saveCacheBitcodeDependencies() {

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/NativeGenerationState.kt

@@ -30,9 +30,8 @@ internal class InlineFunctionOriginInfo(val irFunction: IrFunction, val irFile:
 internal class NativeGenerationState(private val context: Context) {
     private val config = context.config
 
-    private val explicitlyProducePerFileCache = config.producePerFileCache && !config.produceBatchedPerFileCache
-    private val outputPath = config.cacheSupport.tryGetImplicitOutput(explicitlyProducePerFileCache) ?: config.outputPath
-    val outputFiles = OutputFiles(outputPath, config.target, config.produce, explicitlyProducePerFileCache)
+    private val outputPath = config.cacheSupport.tryGetImplicitOutput() ?: config.outputPath
+    val outputFiles = OutputFiles(outputPath, config.target, config.produce)
     val tempFiles = run {
         val pathToTempDir = config.configuration.get(KonanConfigKeys.TEMPORARY_FILES_DIR)?.let {
             val singleFileStrategy = config.cacheSupport.libraryToCache?.strategy as? CacheDeserializationStrategy.SingleFile

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/OutputFiles.kt

@@ -17,7 +17,7 @@ import kotlin.random.Random
 /**
  * Creates and stores terminal compiler outputs.
  */
-class OutputFiles(val outputName: String, target: KonanTarget, val produce: CompilerOutputKind, val producePerFileCache: Boolean) {
+class OutputFiles(val outputName: String, target: KonanTarget, val produce: CompilerOutputKind) {
 
     private val prefix = produce.prefix(target)
     private val suffix = produce.suffix(target)
@@ -42,26 +42,13 @@ class OutputFiles(val outputName: String, target: KonanTarget, val produce: Comp
 
     val mainFile = File(mainFileName)
 
-    private val pathToPerFileCache =
-            if (producePerFileCache)
-                outputName.substring(0, outputName.lastIndexOf(File.separatorChar) /* skip [PER_FILE_CACHE_BINARY_LEVEL_DIR_NAME]*/)
-            else null
+    val perFileCacheFileName = File(outputName).absoluteFile.name
 
-    val perFileCacheFileName = File(pathToPerFileCache ?: outputName).absoluteFile.name
+    val cacheFileName = File((outputName).fullOutputName()).absoluteFile.name
 
-    val cacheFileName = File((pathToPerFileCache ?: outputName).fullOutputName()).absoluteFile.name
+    private fun File.cacheBinaryPart() = this.child(CachedLibraries.PER_FILE_CACHE_BINARY_LEVEL_DIR_NAME)
 
-    private fun File.cacheBinaryPart() =
-            if (producePerFileCache)
-                this
-            else
-                this.child(CachedLibraries.PER_FILE_CACHE_BINARY_LEVEL_DIR_NAME)
-
-    private fun File.cacheIrPart() =
-            if (producePerFileCache)
-                this
-            else
-                this.child(CachedLibraries.PER_FILE_CACHE_IR_LEVEL_DIR_NAME)
+    private fun File.cacheIrPart() = this.child(CachedLibraries.PER_FILE_CACHE_IR_LEVEL_DIR_NAME)
 
     val dynamicCacheInstallName = File(outputName).cacheBinaryPart().child(cacheFileName).absolutePath
 

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/PsiToIr.kt

@@ -77,7 +77,7 @@ internal fun Context.psiToIr(
     )
     val irBuiltInsOverDescriptors = generatorContext.irBuiltIns as IrBuiltInsOverDescriptors
     val functionIrClassFactory: KonanIrAbstractDescriptorBasedFunctionFactory =
-            if (shouldDefineFunctionClasses || (!config.lazyIrForCaches && !config.producePerFileCache))
+            if (shouldDefineFunctionClasses || !config.lazyIrForCaches)
                 BuiltInFictitiousFunctionIrClassFactory(symbolTable, irBuiltInsOverDescriptors, reflectionTypes)
             else
                 LazyIrFunctionFactory(symbolTable, stubGenerator, irBuiltInsOverDescriptors, reflectionTypes)

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/ToplevelPhases.kt

@@ -539,8 +539,8 @@ internal fun PhaseConfig.konanPhasesConfig(config: KonanConfig) {
 
         disable(localEscapeAnalysisPhase)
 
-        disableIf(singleCompilation, config.produceBatchedPerFileCache)
-        disableUnless(umbrellaCompilation, config.produceBatchedPerFileCache)
+        disableIf(singleCompilation, config.producePerFileCache)
+        disableUnless(umbrellaCompilation, config.producePerFileCache)
 
         // Don't serialize anything to a final executable.
         disableUnless(serializerPhase, config.produce == CompilerOutputKind.LIBRARY)

kotlin-native/backend.native/compiler/ir/backend.native/src/org/jetbrains/kotlin/backend/konan/lower/NativeInlineFunctionResolver.kt

@@ -45,7 +45,7 @@ internal class NativeInlineFunctionResolver(override val context: Context) : Def
 
         val packageFragment = function.getPackageFragment()
         val (possiblyLoweredFunction, shouldLower) = if (packageFragment !is IrExternalPackageFragment) {
-            context.inlineFunctionsSupport.getNonLoweredInlineFunction(function, copy = context.config.produceBatchedPerFileCache).also {
+            context.inlineFunctionsSupport.getNonLoweredInlineFunction(function, copy = context.config.producePerFileCache).also {
                 context.generationState.loweredInlineFunctions[function] =
                         InlineFunctionOriginInfo(it, packageFragment as IrFile, function.startOffset, function.endOffset)
             } to true

kotlin-native/utilities/cli-runner/src/main/kotlin/org/jetbrains/kotlin/cli/utilities/GeneratePlatformLibraries.kt

@@ -299,7 +299,7 @@ private fun getLibraryCacheDir(
 ): File {
     val cacheBaseName = CachedLibraries.getCachedLibraryName(libraryName)
     val cacheOutputKind = CompilerOutputKind.valueOf(cacheKind.uppercase())
-    return OutputFiles(cacheDirectory.child(cacheBaseName).absolutePath, target, cacheOutputKind, producePerFileCache = false).mainFile
+    return OutputFiles(cacheDirectory.child(cacheBaseName).absolutePath, target, cacheOutputKind).mainFile
 }
 
 private fun buildCache(