From 77d74a261d633c8ab3406e32d6444bc46c658c78 Mon Sep 17 00:00:00 2001 From: Alexey Tsvetkov Date: Wed, 17 Apr 2019 19:17:04 +0300 Subject: [PATCH] Rename SourceFileToPathConverter->FileToPathConverter --- .../incremental/AbstractIncrementalCache.kt | 12 +++++----- .../kotlin/incremental/IncrementalJsCache.kt | 24 +++++++++---------- .../kotlin/incremental/IncrementalJvmCache.kt | 14 +++++------ .../kotlin/incremental/LookupStorage.kt | 6 ++--- .../storage/ComplementarySourceFilesMap.kt | 10 ++++---- .../kotlin/incremental/storage/FileToIdMap.kt | 10 ++++---- ...athConverter.kt => FileToPathConverter.kt} | 8 +++---- .../kotlin/incremental/storage/IdToFileMap.kt | 6 ++--- .../incremental/storage/SourceToOutputMaps.kt | 20 ++++++++-------- .../incremental/IncrementalCachesManager.kt | 4 ++-- ...Converter.kt => JpsFileToPathConverter.kt} | 4 ++-- .../kotlin/jps/build/KotlinCompileContext.kt | 10 ++++---- .../jps/incremental/JpsIncrementalCache.kt | 10 ++++---- .../jps/incremental/JpsLookupStorage.kt | 14 +++++------ .../jps/targets/KotlinJsModuleBuildTarget.kt | 2 +- .../jps/targets/KotlinJvmModuleBuildTarget.kt | 2 +- 16 files changed, 77 insertions(+), 79 deletions(-) rename build-common/src/org/jetbrains/kotlin/incremental/storage/{SourceFileToPathConverter.kt => FileToPathConverter.kt} (64%) rename jps-plugin/src/org/jetbrains/kotlin/jps/build/{JpsSourceFileToPathConverter.kt => JpsFileToPathConverter.kt} (87%) diff --git a/build-common/src/org/jetbrains/kotlin/incremental/AbstractIncrementalCache.kt b/build-common/src/org/jetbrains/kotlin/incremental/AbstractIncrementalCache.kt index dada248fcfc..fedb2949dc8 100644 --- a/build-common/src/org/jetbrains/kotlin/incremental/AbstractIncrementalCache.kt +++ b/build-common/src/org/jetbrains/kotlin/incremental/AbstractIncrementalCache.kt @@ -47,7 +47,7 @@ interface IncrementalCacheCommon { */ abstract class AbstractIncrementalCache( workingDir: File, - protected val sourcePathConverter: SourceFileToPathConverter + protected val pathConverter: FileToPathConverter ) : BasicMapsOwner(workingDir), IncrementalCacheCommon { companion object { private val SUBTYPES = "subtypes" @@ -73,7 +73,7 @@ abstract class AbstractIncrementalCache( private val subtypesMap = registerMap(SubtypesMap(SUBTYPES.storageFile)) private val supertypesMap = registerMap(SupertypesMap(SUPERTYPES.storageFile)) - protected val classFqNameToSourceMap = registerMap(ClassFqNameToSourceMap(CLASS_FQ_NAME_TO_SOURCE.storageFile, sourcePathConverter)) + protected val classFqNameToSourceMap = registerMap(ClassFqNameToSourceMap(CLASS_FQ_NAME_TO_SOURCE.storageFile, pathConverter)) internal abstract val sourceToClassesMap: AbstractSourceToOutputMap internal abstract val dirtyOutputClassesMap: AbstractDirtyClassesMap /** @@ -82,7 +82,7 @@ abstract class AbstractIncrementalCache( * about missing parts. * TODO: provide a better solution (maintain an index of expect/actual declarations akin to IncrementalPackagePartProvider) */ - private val complementaryFilesMap = registerMap(ComplementarySourceFilesMap(COMPLEMENTARY_FILES.storageFile, sourcePathConverter)) + private val complementaryFilesMap = registerMap(ComplementarySourceFilesMap(COMPLEMENTARY_FILES.storageFile, pathConverter)) override fun classesFqNamesBySources(files: Iterable): Collection = files.flatMapTo(HashSet()) { sourceToClassesMap.getFqNames(it) } @@ -157,15 +157,15 @@ abstract class AbstractIncrementalCache( protected class ClassFqNameToSourceMap( storageFile: File, - private val sourcePathConverter: SourceFileToPathConverter + private val pathConverter: FileToPathConverter ) : BasicStringMap(storageFile, EnumeratorStringDescriptor(), PathStringDescriptor) { operator fun set(fqName: FqName, sourceFile: File) { - storage[fqName.asString()] = sourcePathConverter.toPath(sourceFile) + storage[fqName.asString()] = pathConverter.toPath(sourceFile) } operator fun get(fqName: FqName): File? = - storage[fqName.asString()]?.let(sourcePathConverter::toFile) + storage[fqName.asString()]?.let(pathConverter::toFile) fun remove(fqName: FqName) { storage.remove(fqName.asString()) diff --git a/build-common/src/org/jetbrains/kotlin/incremental/IncrementalJsCache.kt b/build-common/src/org/jetbrains/kotlin/incremental/IncrementalJsCache.kt index e27e5c34062..0ea6a68b0ab 100644 --- a/build-common/src/org/jetbrains/kotlin/incremental/IncrementalJsCache.kt +++ b/build-common/src/org/jetbrains/kotlin/incremental/IncrementalJsCache.kt @@ -35,8 +35,8 @@ import java.io.File open class IncrementalJsCache( cachesDir: File, - sourcePathConverter: SourceFileToPathConverter -) : AbstractIncrementalCache(cachesDir, sourcePathConverter) { + pathConverter: FileToPathConverter +) : AbstractIncrementalCache(cachesDir, pathConverter) { companion object { private const val TRANSLATION_RESULT_MAP = "translation-result" private const val INLINE_FUNCTIONS = "inline-functions" @@ -45,10 +45,10 @@ open class IncrementalJsCache( fun hasHeaderFile(cachesDir: File) = File(cachesDir, HEADER_FILE_NAME).exists() } - override val sourceToClassesMap = registerMap(SourceToFqNameMap(SOURCE_TO_CLASSES.storageFile, sourcePathConverter)) + override val sourceToClassesMap = registerMap(SourceToFqNameMap(SOURCE_TO_CLASSES.storageFile, pathConverter)) override val dirtyOutputClassesMap = registerMap(DirtyClassesFqNameMap(DIRTY_OUTPUT_CLASSES.storageFile)) - private val translationResults = registerMap(TranslationResultMap(TRANSLATION_RESULT_MAP.storageFile, sourcePathConverter)) - private val inlineFunctions = registerMap(InlineFunctionsMap(INLINE_FUNCTIONS.storageFile, sourcePathConverter)) + private val translationResults = registerMap(TranslationResultMap(TRANSLATION_RESULT_MAP.storageFile, pathConverter)) + private val inlineFunctions = registerMap(InlineFunctionsMap(INLINE_FUNCTIONS.storageFile, pathConverter)) private val dirtySources = hashSetOf() @@ -154,24 +154,24 @@ private object TranslationResultValueExternalizer : DataExternalizer(storageFile, TranslationResultValueExternalizer) { override fun dumpValue(value: TranslationResultValue): String = "Metadata: ${value.metadata.md5()}, Binary AST: ${value.binaryAst.md5()}, InlineData: ${value.inlineData.md5()}" fun put(sourceFile: File, newMetadata: ByteArray, newBinaryAst: ByteArray, newInlineData: ByteArray) { - storage[sourcePathConverter.toPath(sourceFile)] = + storage[pathConverter.toPath(sourceFile)] = TranslationResultValue(metadata = newMetadata, binaryAst = newBinaryAst, inlineData = newInlineData) } operator fun get(sourceFile: File): TranslationResultValue? = - storage[sourcePathConverter.toPath(sourceFile)] + storage[pathConverter.toPath(sourceFile)] fun keys(): Collection = storage.keys fun remove(sourceFile: File, changesCollector: ChangesCollector) { - val path = sourcePathConverter.toPath(sourceFile) + val path = pathConverter.toPath(sourceFile) val protoBytes = storage[path]!!.metadata val protoMap = getProtoData(sourceFile, protoBytes) @@ -203,10 +203,10 @@ fun getProtoData(sourceFile: File, metadata: ByteArray): Map private class InlineFunctionsMap( storageFile: File, - private val sourcePathConverter: SourceFileToPathConverter + private val pathConverter: FileToPathConverter ) : BasicStringMap>(storageFile, StringToLongMapExternalizer) { fun process(srcFile: File, newMap: Map, changesCollector: ChangesCollector) { - val key = sourcePathConverter.toPath(srcFile) + val key = pathConverter.toPath(srcFile) val oldMap = storage[key] ?: emptyMap() if (newMap.isNotEmpty()) { @@ -223,7 +223,7 @@ private class InlineFunctionsMap( } fun remove(sourceFile: File) { - storage.remove(sourcePathConverter.toPath(sourceFile)) + storage.remove(pathConverter.toPath(sourceFile)) } override fun dumpValue(value: Map): String = diff --git a/build-common/src/org/jetbrains/kotlin/incremental/IncrementalJvmCache.kt b/build-common/src/org/jetbrains/kotlin/incremental/IncrementalJvmCache.kt index 93dbc0eaaf1..fbab613d71c 100644 --- a/build-common/src/org/jetbrains/kotlin/incremental/IncrementalJvmCache.kt +++ b/build-common/src/org/jetbrains/kotlin/incremental/IncrementalJvmCache.kt @@ -44,10 +44,10 @@ val KOTLIN_CACHE_DIRECTORY_NAME = "kotlin" open class IncrementalJvmCache( private val targetDataRoot: File, targetOutputDir: File?, - sourcePathConverter: SourceFileToPathConverter + pathConverter: FileToPathConverter ) : AbstractIncrementalCache( workingDir = File(targetDataRoot, KOTLIN_CACHE_DIRECTORY_NAME), - sourcePathConverter = sourcePathConverter + pathConverter = pathConverter ), IncrementalCache { companion object { private val PROTO_MAP = "proto" @@ -62,7 +62,7 @@ open class IncrementalJvmCache( private val MODULE_MAPPING_FILE_NAME = "." + ModuleMapping.MAPPING_FILE_EXT } - override val sourceToClassesMap = registerMap(SourceToJvmNameMap(SOURCE_TO_CLASSES.storageFile, sourcePathConverter)) + override val sourceToClassesMap = registerMap(SourceToJvmNameMap(SOURCE_TO_CLASSES.storageFile, pathConverter)) override val dirtyOutputClassesMap = registerMap(DirtyClassesJvmNameMap(DIRTY_OUTPUT_CLASSES.storageFile)) private val protoMap = registerMap(ProtoMap(PROTO_MAP.storageFile)) @@ -72,7 +72,7 @@ open class IncrementalJvmCache( private val partToMultifileFacade = registerMap(MultifileClassPartMap(MULTIFILE_CLASS_PARTS.storageFile)) private val inlineFunctionsMap = registerMap(InlineFunctionsMap(INLINE_FUNCTIONS.storageFile)) // todo: try to use internal names only? - private val internalNameToSource = registerMap(InternalNameToSourcesMap(INTERNAL_NAME_TO_SOURCE.storageFile, sourcePathConverter)) + private val internalNameToSource = registerMap(InternalNameToSourcesMap(INTERNAL_NAME_TO_SOURCE.storageFile, pathConverter)) // gradle only private val javaSourcesProtoMap = registerMap(JavaSourcesProtoMap(JAVA_SOURCES_PROTO_MAP.storageFile)) @@ -447,14 +447,14 @@ open class IncrementalJvmCache( inner class InternalNameToSourcesMap( storageFile: File, - private val sourcePathConverter: SourceFileToPathConverter + private val pathConverter: FileToPathConverter ) : BasicStringMap>(storageFile, EnumeratorStringDescriptor(), PathCollectionExternalizer) { operator fun set(internalName: String, sourceFiles: Collection) { - storage[internalName] = sourcePathConverter.toPaths(sourceFiles) + storage[internalName] = pathConverter.toPaths(sourceFiles) } operator fun get(internalName: String): Collection = - sourcePathConverter.toFiles(storage[internalName] ?: emptyList()) + pathConverter.toFiles(storage[internalName] ?: emptyList()) fun remove(internalName: String) { storage.remove(internalName) diff --git a/build-common/src/org/jetbrains/kotlin/incremental/LookupStorage.kt b/build-common/src/org/jetbrains/kotlin/incremental/LookupStorage.kt index 93f1fa1707f..b865cd9646b 100644 --- a/build-common/src/org/jetbrains/kotlin/incremental/LookupStorage.kt +++ b/build-common/src/org/jetbrains/kotlin/incremental/LookupStorage.kt @@ -32,7 +32,7 @@ import java.util.* open class LookupStorage( targetDataDir: File, - sourcePathConverter: SourceFileToPathConverter + pathConverter: FileToPathConverter ) : BasicMapsOwner(targetDataDir) { companion object { private val DELETED_TO_SIZE_TRESHOLD = 0.5 @@ -40,8 +40,8 @@ open class LookupStorage( } private val countersFile = "counters".storageFile - private val idToFile = registerMap(IdToFileMap("id-to-file".storageFile, sourcePathConverter)) - private val fileToId = registerMap(FileToIdMap("file-to-id".storageFile, sourcePathConverter)) + private val idToFile = registerMap(IdToFileMap("id-to-file".storageFile, pathConverter)) + private val fileToId = registerMap(FileToIdMap("file-to-id".storageFile, pathConverter)) private val lookupMap = registerMap(LookupMap("lookups".storageFile)) @Volatile diff --git a/build-common/src/org/jetbrains/kotlin/incremental/storage/ComplementarySourceFilesMap.kt b/build-common/src/org/jetbrains/kotlin/incremental/storage/ComplementarySourceFilesMap.kt index 12d0ccdcce4..9f2083b44a4 100644 --- a/build-common/src/org/jetbrains/kotlin/incremental/storage/ComplementarySourceFilesMap.kt +++ b/build-common/src/org/jetbrains/kotlin/incremental/storage/ComplementarySourceFilesMap.kt @@ -10,21 +10,21 @@ import java.io.File class ComplementarySourceFilesMap( storageFile: File, - private val sourcePathConverter: SourceFileToPathConverter + private val pathConverter: FileToPathConverter ) : BasicStringMap>(storageFile, PathStringDescriptor, StringCollectionExternalizer) { operator fun set(sourceFile: File, complementaryFiles: Collection) { - storage[sourcePathConverter.toPath(sourceFile)] = sourcePathConverter.toPaths(complementaryFiles) + storage[pathConverter.toPath(sourceFile)] = pathConverter.toPaths(complementaryFiles) } operator fun get(sourceFile: File): Collection { - val paths = storage[sourcePathConverter.toPath(sourceFile)].orEmpty() - return sourcePathConverter.toFiles(paths) + val paths = storage[pathConverter.toPath(sourceFile)].orEmpty() + return pathConverter.toFiles(paths) } override fun dumpValue(value: Collection) = value.dumpCollection() fun remove(file: File): Collection = - get(file).also { storage.remove(sourcePathConverter.toPath(file)) } + get(file).also { storage.remove(pathConverter.toPath(file)) } } \ No newline at end of file diff --git a/build-common/src/org/jetbrains/kotlin/incremental/storage/FileToIdMap.kt b/build-common/src/org/jetbrains/kotlin/incremental/storage/FileToIdMap.kt index 3b62f957390..1c3d750a02a 100644 --- a/build-common/src/org/jetbrains/kotlin/incremental/storage/FileToIdMap.kt +++ b/build-common/src/org/jetbrains/kotlin/incremental/storage/FileToIdMap.kt @@ -20,25 +20,25 @@ import java.io.File internal class FileToIdMap( file: File, - private val sourcePathConverter: SourceFileToPathConverter + private val pathConverter: FileToPathConverter ) : BasicStringMap(file, IntExternalizer) { override fun dumpValue(value: Int): String = value.toString() - operator fun get(file: File): Int? = storage[sourcePathConverter.toPath(file)] + operator fun get(file: File): Int? = storage[pathConverter.toPath(file)] operator fun set(file: File, id: Int) { - storage[sourcePathConverter.toPath(file)] = id + storage[pathConverter.toPath(file)] = id } fun remove(file: File) { - storage.remove(sourcePathConverter.toPath(file)) + storage.remove(pathConverter.toPath(file)) } fun toMap(): Map { val result = HashMap() for (key in storage.keys) { val value = storage[key] ?: continue - result[sourcePathConverter.toFile(key)] = value + result[pathConverter.toFile(key)] = value } return result } diff --git a/build-common/src/org/jetbrains/kotlin/incremental/storage/SourceFileToPathConverter.kt b/build-common/src/org/jetbrains/kotlin/incremental/storage/FileToPathConverter.kt similarity index 64% rename from build-common/src/org/jetbrains/kotlin/incremental/storage/SourceFileToPathConverter.kt rename to build-common/src/org/jetbrains/kotlin/incremental/storage/FileToPathConverter.kt index a6fe8fd8698..301f6a7419b 100644 --- a/build-common/src/org/jetbrains/kotlin/incremental/storage/SourceFileToPathConverter.kt +++ b/build-common/src/org/jetbrains/kotlin/incremental/storage/FileToPathConverter.kt @@ -7,18 +7,18 @@ package org.jetbrains.kotlin.incremental.storage import java.io.File -interface SourceFileToPathConverter { +interface FileToPathConverter { fun toPath(file: File): String fun toFile(path: String): File } -fun SourceFileToPathConverter.toPaths(files: Collection): List = +fun FileToPathConverter.toPaths(files: Collection): List = files.map { toPath(it) } -fun SourceFileToPathConverter.toFiles(paths: Collection): List = +fun FileToPathConverter.toFiles(paths: Collection): List = paths.map { toFile(it) } -object SourceFileToCanonicalPathConverter : SourceFileToPathConverter { +object FileToCanonicalPathConverter : FileToPathConverter { override fun toPath(file: File): String = file.canonicalPath override fun toFile(path: String): File = File(path) diff --git a/build-common/src/org/jetbrains/kotlin/incremental/storage/IdToFileMap.kt b/build-common/src/org/jetbrains/kotlin/incremental/storage/IdToFileMap.kt index cc5e6ce5fae..e43469adea7 100644 --- a/build-common/src/org/jetbrains/kotlin/incremental/storage/IdToFileMap.kt +++ b/build-common/src/org/jetbrains/kotlin/incremental/storage/IdToFileMap.kt @@ -22,18 +22,18 @@ import java.io.File internal class IdToFileMap( file: File, - private val sourcePathConverter: SourceFileToPathConverter + private val pathConverter: FileToPathConverter ) : BasicMap(file, ExternalIntegerKeyDescriptor(), EnumeratorStringDescriptor.INSTANCE) { override fun dumpKey(key: Int): String = key.toString() override fun dumpValue(value: String): String = value - operator fun get(id: Int): File? = storage[id]?.let { sourcePathConverter.toFile(it) } + operator fun get(id: Int): File? = storage[id]?.let { pathConverter.toFile(it) } operator fun contains(id: Int): Boolean = id in storage operator fun set(id: Int, file: File) { - storage[id] = sourcePathConverter.toPath(file) + storage[id] = pathConverter.toPath(file) } fun remove(id: Int) { diff --git a/build-common/src/org/jetbrains/kotlin/incremental/storage/SourceToOutputMaps.kt b/build-common/src/org/jetbrains/kotlin/incremental/storage/SourceToOutputMaps.kt index 63b7a7072df..3e8529ad680 100644 --- a/build-common/src/org/jetbrains/kotlin/incremental/storage/SourceToOutputMaps.kt +++ b/build-common/src/org/jetbrains/kotlin/incremental/storage/SourceToOutputMaps.kt @@ -23,35 +23,35 @@ import java.io.File internal class SourceToJvmNameMap( storageFile: File, - sourcePathConverter: SourceFileToPathConverter -) : AbstractSourceToOutputMap(JvmClassNameTransformer, storageFile, sourcePathConverter) + pathConverter: FileToPathConverter +) : AbstractSourceToOutputMap(JvmClassNameTransformer, storageFile, pathConverter) internal class SourceToFqNameMap( storageFile: File, - sourcePathConverter: SourceFileToPathConverter -) : AbstractSourceToOutputMap(FqNameTransformer, storageFile, sourcePathConverter) + pathConverter: FileToPathConverter +) : AbstractSourceToOutputMap(FqNameTransformer, storageFile, pathConverter) internal abstract class AbstractSourceToOutputMap( private val nameTransformer: NameTransformer, storageFile: File, - private val sourcePathConverter: SourceFileToPathConverter + private val pathConverter: FileToPathConverter ) : BasicStringMap>(storageFile, PathStringDescriptor, StringCollectionExternalizer) { fun clearOutputsForSource(sourceFile: File) { - remove(sourcePathConverter.toPath(sourceFile)) + remove(pathConverter.toPath(sourceFile)) } fun add(sourceFile: File, className: Name) { - storage.append(sourcePathConverter.toPath(sourceFile), nameTransformer.asString(className)) + storage.append(pathConverter.toPath(sourceFile), nameTransformer.asString(className)) } fun contains(sourceFile: File): Boolean = - sourcePathConverter.toPath(sourceFile) in storage + pathConverter.toPath(sourceFile) in storage operator fun get(sourceFile: File): Collection = - storage[sourcePathConverter.toPath(sourceFile)].orEmpty().map(nameTransformer::asName) + storage[pathConverter.toPath(sourceFile)].orEmpty().map(nameTransformer::asName) fun getFqNames(sourceFile: File): Collection = - storage[sourcePathConverter.toPath(sourceFile)].orEmpty().map(nameTransformer::asFqName) + storage[pathConverter.toPath(sourceFile)].orEmpty().map(nameTransformer::asFqName) override fun dumpValue(value: Collection) = value.dumpCollection() diff --git a/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalCachesManager.kt b/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalCachesManager.kt index 5fbcaa18b33..1749655b51f 100644 --- a/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalCachesManager.kt +++ b/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalCachesManager.kt @@ -17,10 +17,10 @@ package org.jetbrains.kotlin.incremental import org.jetbrains.kotlin.incremental.storage.BasicMapsOwner -import org.jetbrains.kotlin.incremental.storage.SourceFileToCanonicalPathConverter +import org.jetbrains.kotlin.incremental.storage.FileToCanonicalPathConverter import java.io.File -private val PATH_CONVERTER = SourceFileToCanonicalPathConverter +private val PATH_CONVERTER = FileToCanonicalPathConverter abstract class IncrementalCachesManager>( cachesRootDir: File, diff --git a/jps-plugin/src/org/jetbrains/kotlin/jps/build/JpsSourceFileToPathConverter.kt b/jps-plugin/src/org/jetbrains/kotlin/jps/build/JpsFileToPathConverter.kt similarity index 87% rename from jps-plugin/src/org/jetbrains/kotlin/jps/build/JpsSourceFileToPathConverter.kt rename to jps-plugin/src/org/jetbrains/kotlin/jps/build/JpsFileToPathConverter.kt index 104a9147f7d..27bebc0467c 100644 --- a/jps-plugin/src/org/jetbrains/kotlin/jps/build/JpsSourceFileToPathConverter.kt +++ b/jps-plugin/src/org/jetbrains/kotlin/jps/build/JpsFileToPathConverter.kt @@ -7,12 +7,12 @@ package org.jetbrains.kotlin.jps.build import org.jetbrains.jps.model.JpsProject import org.jetbrains.jps.model.serialization.JpsModelSerializationDataService -import org.jetbrains.kotlin.incremental.storage.SourceFileToPathConverter +import org.jetbrains.kotlin.incremental.storage.FileToPathConverter import java.io.File private const val PROJECT_DIR_PLACEHOLDER = "${'$'}PROJECT_DIR$" -internal class JpsSourceFileToPathConverter(jpsProject: JpsProject) : SourceFileToPathConverter { +internal class JpsFileToPathConverter(jpsProject: JpsProject) : FileToPathConverter { private val baseDirPath = JpsModelSerializationDataService .getBaseDirectory(jpsProject)?.canonicalFile?.invariantSeparatorsPath diff --git a/jps-plugin/src/org/jetbrains/kotlin/jps/build/KotlinCompileContext.kt b/jps-plugin/src/org/jetbrains/kotlin/jps/build/KotlinCompileContext.kt index 380517127b3..e34e4245fa1 100644 --- a/jps-plugin/src/org/jetbrains/kotlin/jps/build/KotlinCompileContext.kt +++ b/jps-plugin/src/org/jetbrains/kotlin/jps/build/KotlinCompileContext.kt @@ -12,11 +12,9 @@ import org.jetbrains.jps.incremental.GlobalContextKey import org.jetbrains.jps.incremental.fs.CompilationRound import org.jetbrains.jps.incremental.messages.BuildMessage import org.jetbrains.jps.incremental.messages.CompilerMessage -import org.jetbrains.jps.model.serialization.JpsModelSerializationDataService import org.jetbrains.kotlin.config.CompilerRunnerConstants import org.jetbrains.kotlin.incremental.LookupSymbol -import org.jetbrains.kotlin.incremental.storage.SourceFileToCanonicalPathConverter -import org.jetbrains.kotlin.incremental.storage.SourceFileToPathConverter +import org.jetbrains.kotlin.incremental.storage.FileToPathConverter import org.jetbrains.kotlin.jps.incremental.* import org.jetbrains.kotlin.jps.targets.KotlinTargetsIndex import org.jetbrains.kotlin.jps.targets.KotlinTargetsIndexBuilder @@ -69,10 +67,10 @@ class KotlinCompileContext(val jpsContext: CompileContext) { val hasKotlinMarker = HasKotlinMarker(dataManager) - val sourceFileToPathConverter: SourceFileToPathConverter = - JpsSourceFileToPathConverter(jpsContext.projectDescriptor.project) + val fileToPathConverter: FileToPathConverter = + JpsFileToPathConverter(jpsContext.projectDescriptor.project) - val lookupStorageManager = JpsLookupStorageManager(dataManager, sourceFileToPathConverter) + val lookupStorageManager = JpsLookupStorageManager(dataManager, fileToPathConverter) /** * Flag to prevent rebuilding twice. diff --git a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/JpsIncrementalCache.kt b/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/JpsIncrementalCache.kt index 7437c4daa4a..ae74d0345c2 100644 --- a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/JpsIncrementalCache.kt +++ b/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/JpsIncrementalCache.kt @@ -24,7 +24,7 @@ import org.jetbrains.jps.incremental.storage.StorageOwner import org.jetbrains.kotlin.incremental.IncrementalCacheCommon import org.jetbrains.kotlin.incremental.IncrementalJsCache import org.jetbrains.kotlin.incremental.IncrementalJvmCache -import org.jetbrains.kotlin.incremental.storage.SourceFileToPathConverter +import org.jetbrains.kotlin.incremental.storage.FileToPathConverter import org.jetbrains.kotlin.jps.build.KotlinBuilder import org.jetbrains.kotlin.jps.targets.KotlinModuleBuildTarget import java.io.File @@ -36,8 +36,8 @@ interface JpsIncrementalCache : IncrementalCacheCommon, StorageOwner { class JpsIncrementalJvmCache( target: ModuleBuildTarget, paths: BuildDataPaths, - sourcePathConverter: SourceFileToPathConverter -) : IncrementalJvmCache(paths.getTargetDataRoot(target), target.outputDir, sourcePathConverter), JpsIncrementalCache { + pathConverter: FileToPathConverter +) : IncrementalJvmCache(paths.getTargetDataRoot(target), target.outputDir, pathConverter), JpsIncrementalCache { override fun addJpsDependentCache(cache: JpsIncrementalCache) { if (cache is JpsIncrementalJvmCache) { addDependentCache(cache) @@ -52,8 +52,8 @@ class JpsIncrementalJvmCache( class JpsIncrementalJsCache( target: ModuleBuildTarget, paths: BuildDataPaths, - sourcePathConverter: SourceFileToPathConverter -) : IncrementalJsCache(paths.getTargetDataRoot(target), sourcePathConverter), JpsIncrementalCache { + pathConverter: FileToPathConverter +) : IncrementalJsCache(paths.getTargetDataRoot(target), pathConverter), JpsIncrementalCache { override fun addJpsDependentCache(cache: JpsIncrementalCache) { if (cache is JpsIncrementalJsCache) { addDependentCache(cache) diff --git a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/JpsLookupStorage.kt b/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/JpsLookupStorage.kt index 45330f65cf0..0fd2eaaa7be 100644 --- a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/JpsLookupStorage.kt +++ b/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/JpsLookupStorage.kt @@ -22,7 +22,7 @@ import org.jetbrains.jps.builders.storage.StorageProvider import org.jetbrains.jps.incremental.storage.BuildDataManager import org.jetbrains.jps.incremental.storage.StorageOwner import org.jetbrains.kotlin.incremental.LookupStorage -import org.jetbrains.kotlin.incremental.storage.SourceFileToPathConverter +import org.jetbrains.kotlin.incremental.storage.FileToPathConverter import java.io.File import java.io.IOException @@ -30,9 +30,9 @@ private object LookupStorageLock class JpsLookupStorageManager( private val buildDataManager: BuildDataManager, - sourcePathConverter: SourceFileToPathConverter + pathConverter: FileToPathConverter ) { - private val storageProvider = JpsLookupStorageProvider(sourcePathConverter) + private val storageProvider = JpsLookupStorageProvider(pathConverter) fun cleanLookupStorage(log: Logger) { synchronized(LookupStorageLock) { @@ -58,14 +58,14 @@ class JpsLookupStorageManager( } private class JpsLookupStorageProvider( - private val sourcePathConverter: SourceFileToPathConverter + private val pathConverter: FileToPathConverter ) : StorageProvider() { override fun createStorage(targetDataDir: File): JpsLookupStorage = - JpsLookupStorage(targetDataDir, sourcePathConverter) + JpsLookupStorage(targetDataDir, pathConverter) } private class JpsLookupStorage( targetDataDir: File, - sourcePathConverter: SourceFileToPathConverter - ) : StorageOwner, LookupStorage(targetDataDir, sourcePathConverter) + pathConverter: FileToPathConverter + ) : StorageOwner, LookupStorage(targetDataDir, pathConverter) } diff --git a/jps-plugin/src/org/jetbrains/kotlin/jps/targets/KotlinJsModuleBuildTarget.kt b/jps-plugin/src/org/jetbrains/kotlin/jps/targets/KotlinJsModuleBuildTarget.kt index fbd08ad2834..16e466cf5a9 100644 --- a/jps-plugin/src/org/jetbrains/kotlin/jps/targets/KotlinJsModuleBuildTarget.kt +++ b/jps-plugin/src/org/jetbrains/kotlin/jps/targets/KotlinJsModuleBuildTarget.kt @@ -208,7 +208,7 @@ class KotlinJsModuleBuildTarget(kotlinContext: KotlinCompileContext, jpsModuleBu } override fun createCacheStorage(paths: BuildDataPaths) = - JpsIncrementalJsCache(jpsModuleBuildTarget, paths, kotlinContext.sourceFileToPathConverter) + JpsIncrementalJsCache(jpsModuleBuildTarget, paths, kotlinContext.fileToPathConverter) override fun updateCaches( dirtyFilesHolder: KotlinDirtySourceFilesHolder, diff --git a/jps-plugin/src/org/jetbrains/kotlin/jps/targets/KotlinJvmModuleBuildTarget.kt b/jps-plugin/src/org/jetbrains/kotlin/jps/targets/KotlinJvmModuleBuildTarget.kt index 126b50961c7..924c72e8ee4 100644 --- a/jps-plugin/src/org/jetbrains/kotlin/jps/targets/KotlinJvmModuleBuildTarget.kt +++ b/jps-plugin/src/org/jetbrains/kotlin/jps/targets/KotlinJvmModuleBuildTarget.kt @@ -56,7 +56,7 @@ class KotlinJvmModuleBuildTarget(kotlinContext: KotlinCompileContext, jpsModuleB get() = IncrementalCompilation.isEnabledForJvm() override fun createCacheStorage(paths: BuildDataPaths) = - JpsIncrementalJvmCache(jpsModuleBuildTarget, paths, kotlinContext.sourceFileToPathConverter) + JpsIncrementalJvmCache(jpsModuleBuildTarget, paths, kotlinContext.fileToPathConverter) override val buildMetaInfoFactory get() = JvmBuildMetaInfo