KT-34862 use relative path for incremental build cache

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

@@ -17,16 +17,17 @@
 package org.jetbrains.kotlin.incremental
 
 import org.jetbrains.kotlin.incremental.storage.BasicMapsOwner
-import org.jetbrains.kotlin.incremental.storage.FileToCanonicalPathConverter
+import org.jetbrains.kotlin.incremental.storage.IncrementalFileToPathConverter
 import org.jetbrains.kotlin.serialization.SerializerExtensionProtocol
 import java.io.File
 
-private val PATH_CONVERTER = FileToCanonicalPathConverter
 
 abstract class IncrementalCachesManager<PlatformCache : AbstractIncrementalCache<*>>(
     cachesRootDir: File,
+    rootProjectDir: File?,
     protected val reporter: ICReporter
 ) {
+    val pathConverter = IncrementalFileToPathConverter(rootProjectDir)
     private val caches = arrayListOf<BasicMapsOwner>()
     protected fun <T : BasicMapsOwner> T.registerCache() {
         caches.add(this)
@@ -36,7 +37,7 @@ abstract class IncrementalCachesManager<PlatformCache : AbstractIncrementalCache
     private val lookupCacheDir = File(cachesRootDir, "lookups").apply { mkdirs() }
 
     val inputsCache: InputsCache = InputsCache(inputSnapshotsCacheDir, reporter).apply { registerCache() }
-    val lookupCache: LookupStorage = LookupStorage(lookupCacheDir, PATH_CONVERTER).apply { registerCache() }
+    val lookupCache: LookupStorage = LookupStorage(lookupCacheDir, pathConverter).apply { registerCache() }
     abstract val platformCache: PlatformCache
 
     fun close(flush: Boolean = false): Boolean {
@@ -66,20 +67,20 @@ abstract class IncrementalCachesManager<PlatformCache : AbstractIncrementalCache
 
 class IncrementalJvmCachesManager(
     cacheDirectory: File,
+    rootProjectDir: File?,
     outputDir: File,
     reporter: ICReporter
-) : IncrementalCachesManager<IncrementalJvmCache>(cacheDirectory, reporter) {
-
+) : IncrementalCachesManager<IncrementalJvmCache>(cacheDirectory, rootProjectDir, reporter) {
     private val jvmCacheDir = File(cacheDirectory, "jvm").apply { mkdirs() }
-    override val platformCache = IncrementalJvmCache(jvmCacheDir, outputDir, PATH_CONVERTER).apply { registerCache() }
+    override val platformCache = IncrementalJvmCache(jvmCacheDir, outputDir, pathConverter).apply { registerCache() }
 }
 
 class IncrementalJsCachesManager(
     cachesRootDir: File,
+    rootProjectDir: File,
     reporter: ICReporter,
     serializerProtocol: SerializerExtensionProtocol
-) : IncrementalCachesManager<IncrementalJsCache>(cachesRootDir, reporter) {
-
+) : IncrementalCachesManager<IncrementalJsCache>(cachesRootDir, rootProjectDir, reporter) {
     private val jsCacheFile = File(cachesRootDir, "js").apply { mkdirs() }
-    override val platformCache = IncrementalJsCache(jsCacheFile, PATH_CONVERTER, serializerProtocol).apply { registerCache() }
+    override val platformCache = IncrementalJsCache(jsCacheFile, pathConverter, serializerProtocol).apply { registerCache() }
 }

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

@@ -54,7 +54,7 @@ abstract class IncrementalCompilerRunner<
     protected open val kotlinSourceFilesExtensions: List<String> = DEFAULT_KOTLIN_SOURCE_FILES_EXTENSIONS
 
     protected abstract fun isICEnabled(): Boolean
-    protected abstract fun createCacheManager(args: Args): CacheManager
+    protected abstract fun createCacheManager(args: Args, projectDir: File?): CacheManager
     protected abstract fun destinationDir(args: Args): File
 
     fun compile(
@@ -63,16 +63,17 @@ abstract class IncrementalCompilerRunner<
         messageCollector: MessageCollector,
         // when [providedChangedFiles] is not null, changes are provided by external system (e.g. Gradle)
         // otherwise we track source files changes ourselves.
-        providedChangedFiles: ChangedFiles?
+        providedChangedFiles: ChangedFiles?,
+        projectDir: File? = null
     ): ExitCode {
         assert(isICEnabled()) { "Incremental compilation is not enabled" }
-        var caches = createCacheManager(args)
+        var caches = createCacheManager(args, projectDir)
 
         fun rebuild(reason: () -> String): ExitCode {
             reporter.report(reason)
             caches.close(false)
             clearLocalStateOnRebuild(args)
-            caches = createCacheManager(args)
+            caches = createCacheManager(args, projectDir)
             if (providedChangedFiles == null) {
                 caches.inputsCache.sourceSnapshotMap.compareAndUpdate(allSourceFiles)
             }

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

@@ -68,7 +68,7 @@ inline fun <R> withJsIC(fn: () -> R): R {
 }
 
 class IncrementalJsCompilerRunner(
-    workingDir: File,
+    private val workingDir: File,
     reporter: ICReporter,
     buildHistoryFile: File,
     private val modulesApiHistory: ModulesApiHistory,
@@ -82,9 +82,9 @@ class IncrementalJsCompilerRunner(
     override fun isICEnabled(): Boolean =
         IncrementalCompilation.isEnabledForJs()
 
-    override fun createCacheManager(args: K2JSCompilerArguments): IncrementalJsCachesManager {
+    override fun createCacheManager(args: K2JSCompilerArguments, projectDir: File?): IncrementalJsCachesManager {
         val serializerProtocol = if (!args.isIrBackendEnabled()) JsSerializerProtocol else KlibMetadataSerializerProtocol
-        return IncrementalJsCachesManager(cacheDirectory, reporter, serializerProtocol)
+        return IncrementalJsCachesManager(cacheDirectory, workingDir, reporter, serializerProtocol)
     }
 
     override fun destinationDir(args: K2JSCompilerArguments): File =

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

@@ -120,8 +120,9 @@ class IncrementalJvmCompilerRunner(
     override fun isICEnabled(): Boolean =
         IncrementalCompilation.isEnabledForJvm()
 
-    override fun createCacheManager(args: K2JVMCompilerArguments): IncrementalJvmCachesManager =
-        IncrementalJvmCachesManager(cacheDirectory, File(args.destination), reporter)
+    //TODO
+    override fun createCacheManager(args: K2JVMCompilerArguments, projectDir: File?): IncrementalJvmCachesManager =
+        IncrementalJvmCachesManager(cacheDirectory, projectDir, File(args.destination), reporter)
 
     override fun destinationDir(args: K2JVMCompilerArguments): File =
         args.destinationAsFile