From f144bb38dad1c91fac1c3d2818a37b9d46fb3bda Mon Sep 17 00:00:00 2001 From: Zalim Bashorov Date: Wed, 11 Nov 2015 20:30:41 +0300 Subject: [PATCH] ChangesInfo -> CompilationResult --- .../kotlin/jps/build/KotlinBuilder.kt | 14 ++--- .../jps/incremental/IncrementalCacheImpl.kt | 58 +++++++++---------- 2 files changed, 36 insertions(+), 36 deletions(-) diff --git a/jps-plugin/src/org/jetbrains/kotlin/jps/build/KotlinBuilder.kt b/jps-plugin/src/org/jetbrains/kotlin/jps/build/KotlinBuilder.kt index d8bf653bbab..c50acc74e42 100644 --- a/jps-plugin/src/org/jetbrains/kotlin/jps/build/KotlinBuilder.kt +++ b/jps-plugin/src/org/jetbrains/kotlin/jps/build/KotlinBuilder.kt @@ -217,7 +217,7 @@ public class KotlinBuilder : ModuleLevelBuilder(BuilderCategory.SOURCE_PROCESSOR allCompiledFiles: MutableSet, dataManager: BuildDataManager, caches: List, - changesInfo: ChangesInfo + compilationResult: CompilationResult ) { fun recompileInlined() { for (cache in caches) { @@ -229,7 +229,7 @@ public class KotlinBuilder : ModuleLevelBuilder(BuilderCategory.SOURCE_PROCESSOR } } - fun ChangesInfo.doProcessChanges() { + fun CompilationResult.doProcessChanges() { fun isKotlin(file: File) = KotlinSourceFileCollector.isKotlinSourceFile(file) fun isNotCompiled(file: File) = file !in allCompiledFiles @@ -253,7 +253,7 @@ public class KotlinBuilder : ModuleLevelBuilder(BuilderCategory.SOURCE_PROCESSOR } } - fun ChangesInfo.doProcessChangesUsingLookups() { + fun CompilationResult.doProcessChangesUsingLookups() { val lookupStorage = dataManager.getStorage(KotlinDataContainerTarget, LookupStorageProvider) // TODO group by fqName? @@ -276,10 +276,10 @@ public class KotlinBuilder : ModuleLevelBuilder(BuilderCategory.SOURCE_PROCESSOR } if (IncrementalCompilation.isExperimental()) { - changesInfo.doProcessChangesUsingLookups() + compilationResult.doProcessChangesUsingLookups() } else { - changesInfo.doProcessChanges() + compilationResult.doProcessChanges() } } @@ -449,13 +449,13 @@ public class KotlinBuilder : ModuleLevelBuilder(BuilderCategory.SOURCE_PROCESSOR incrementalCaches: Map, generatedFiles: List, chunk: ModuleChunk - ): ChangesInfo { + ): CompilationResult { assert(IncrementalCompilation.isEnabled()) { "updateKotlinIncrementalCache should not be called when incremental compilation disabled" } chunk.targets.forEach { incrementalCaches[it]!!.saveCacheFormatVersion() } - var changesInfo = ChangesInfo.NO_CHANGES + var changesInfo = CompilationResult.NO_CHANGES for (generatedFile in generatedFiles) { val ic = incrementalCaches[generatedFile.target]!! val newChangesInfo = diff --git a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/IncrementalCacheImpl.kt b/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/IncrementalCacheImpl.kt index 2692a562e7a..78f0baed915 100644 --- a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/IncrementalCacheImpl.kt +++ b/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/IncrementalCacheImpl.kt @@ -144,15 +144,15 @@ public class IncrementalCacheImpl( cacheFormatVersion.saveIfNeeded() } - public fun saveModuleMappingToCache(sourceFiles: Collection, file: File): ChangesInfo { + public fun saveModuleMappingToCache(sourceFiles: Collection, file: File): CompilationResult { val jvmClassName = JvmClassName.byInternalName(MODULE_MAPPING_FILE_NAME) protoMap.process(jvmClassName, file.readBytes(), emptyArray(), isPackage = false, checkChangesIsOpenPart = false) dirtyOutputClassesMap.notDirty(MODULE_MAPPING_FILE_NAME) sourceFiles.forEach { sourceToClassesMap.add(it, jvmClassName) } - return ChangesInfo.NO_CHANGES + return CompilationResult.NO_CHANGES } - public fun saveFileToCache(generatedClass: GeneratedJvmClass): ChangesInfo { + public fun saveFileToCache(generatedClass: GeneratedJvmClass): CompilationResult { val sourceFiles: Collection = generatedClass.sourceFiles val kotlinClass: LocalFileKotlinClass = generatedClass.outputClass val className = JvmClassName.byClassId(kotlinClass.classId) @@ -203,20 +203,20 @@ public class IncrementalCacheImpl( constantsMap.process(kotlinClass) + inlineFunctionsMap.process(kotlinClass, isPackage) } - else -> ChangesInfo.NO_CHANGES + else -> CompilationResult.NO_CHANGES } changesInfo.logIfSomethingChanged(className) return changesInfo } - private fun ChangesInfo.logIfSomethingChanged(className: JvmClassName) { - if (this == ChangesInfo.NO_CHANGES) return + private fun CompilationResult.logIfSomethingChanged(className: JvmClassName) { + if (this == CompilationResult.NO_CHANGES) return KotlinBuilder.LOG.debug("$className is changed: $this") } - public fun clearCacheForRemovedClasses(): ChangesInfo { + public fun clearCacheForRemovedClasses(): CompilationResult { fun T.getNonPrivateNames(nameResolver: NameResolver, vararg members: T.() -> List) = members.flatMap { this.it().filterNot { it.isPrivate }.names(nameResolver) }.toSet() @@ -267,9 +267,9 @@ public class IncrementalCacheImpl( else emptySequence() - val changesInfo = dirtyClasses.fold(ChangesInfo(changes = changes)) { info, className -> - val newInfo = ChangesInfo(protoChanged = className in protoMap, - constantsChanged = className in constantsMap) + val changesInfo = dirtyClasses.fold(CompilationResult(changes = changes)) { info, className -> + val newInfo = CompilationResult(protoChanged = className in protoMap, + constantsChanged = className in constantsMap) newInfo.logIfSomethingChanged(className) info + newInfo } @@ -329,19 +329,19 @@ public class IncrementalCacheImpl( private inner class ProtoMap(storageFile: File) : BasicStringMap(storageFile, ProtoMapValueExternalizer) { - public fun process(kotlinClass: LocalFileKotlinClass, isPackage: Boolean): ChangesInfo { + public fun process(kotlinClass: LocalFileKotlinClass, isPackage: Boolean): CompilationResult { val header = kotlinClass.classHeader val bytes = BitEncoding.decodeBytes(header.annotationData!!) return put(kotlinClass.className, bytes, header.strings!!, isPackage, checkChangesIsOpenPart = true) } - public fun process(className: JvmClassName, data: ByteArray, strings: Array, isPackage: Boolean, checkChangesIsOpenPart: Boolean): ChangesInfo { + public fun process(className: JvmClassName, data: ByteArray, strings: Array, isPackage: Boolean, checkChangesIsOpenPart: Boolean): CompilationResult { return put(className, data, strings, isPackage, checkChangesIsOpenPart) } private fun put( className: JvmClassName, bytes: ByteArray, strings: Array, isPackage: Boolean, checkChangesIsOpenPart: Boolean - ): ChangesInfo { + ): CompilationResult { val key = className.internalName val oldData = storage[key] val data = ProtoMapValue(isPackage, bytes, strings) @@ -354,11 +354,11 @@ public class IncrementalCacheImpl( storage[key] = data } - if (oldData == null || !checkChangesIsOpenPart) return ChangesInfo(protoChanged = true) + if (oldData == null || !checkChangesIsOpenPart) return CompilationResult(protoChanged = true) val diff = difference(oldData, data) - if (!IncrementalCompilation.isExperimental()) return ChangesInfo(protoChanged = diff != DifferenceKind.NONE) + if (!IncrementalCompilation.isExperimental()) return CompilationResult(protoChanged = diff != DifferenceKind.NONE) val fqName = if (isPackage) className.packageFqName else className.fqNameForClassNameWithoutDollars @@ -369,7 +369,7 @@ public class IncrementalCacheImpl( is DifferenceKind.MEMBERS -> sequenceOf(ChangeInfo.MembersChanged(fqName, diff.names)) } - return ChangesInfo(protoChanged = diff != DifferenceKind.NONE, changes = changes) + return CompilationResult(protoChanged = diff != DifferenceKind.NONE, changes = changes) } public fun contains(className: JvmClassName): Boolean = @@ -407,15 +407,15 @@ public class IncrementalCacheImpl( fun contains(className: JvmClassName): Boolean = className.internalName in storage - public fun process(kotlinClass: LocalFileKotlinClass): ChangesInfo { + public fun process(kotlinClass: LocalFileKotlinClass): CompilationResult { return put(kotlinClass.className, getConstantsMap(kotlinClass.fileContents)) } - private fun put(className: JvmClassName, constantsMap: Map?): ChangesInfo { + private fun put(className: JvmClassName, constantsMap: Map?): CompilationResult { val key = className.getInternalName() val oldMap = storage[key] - if (oldMap == constantsMap) return ChangesInfo.NO_CHANGES + if (oldMap == constantsMap) return CompilationResult.NO_CHANGES if (constantsMap != null) { storage[key] = constantsMap @@ -424,7 +424,7 @@ public class IncrementalCacheImpl( storage.remove(key) } - return ChangesInfo(constantsChanged = true) + return CompilationResult(constantsChanged = true) } public fun remove(className: JvmClassName) { @@ -463,11 +463,11 @@ public class IncrementalCacheImpl( return result } - public fun process(kotlinClass: LocalFileKotlinClass, isPackage: Boolean): ChangesInfo { + public fun process(kotlinClass: LocalFileKotlinClass, isPackage: Boolean): CompilationResult { return put(kotlinClass.className, getInlineFunctionsMap(kotlinClass.fileContents), isPackage) } - private fun put(className: JvmClassName, newMap: Map, isPackage: Boolean): ChangesInfo { + private fun put(className: JvmClassName, newMap: Map, isPackage: Boolean): CompilationResult { val internalName = className.internalName val oldMap = storage[internalName] ?: emptyMap() @@ -504,9 +504,9 @@ public class IncrementalCacheImpl( emptySequence() } - return ChangesInfo(inlineChanged = changed.isNotEmpty(), - inlineAdded = added.isNotEmpty(), - changes = changes) + return CompilationResult(inlineChanged = changed.isNotEmpty(), + inlineAdded = added.isNotEmpty(), + changes = changes) } public fun remove(className: JvmClassName) { @@ -651,7 +651,7 @@ sealed class ChangeInfo(val fqName: FqName) { class SignatureChanged(fqName: FqName) : ChangeInfo(fqName) } -data class ChangesInfo( +data class CompilationResult( val protoChanged: Boolean = false, val constantsChanged: Boolean = false, val inlineChanged: Boolean = false, @@ -659,11 +659,11 @@ data class ChangesInfo( val changes: Sequence = emptySequence() ) { companion object { - public val NO_CHANGES: ChangesInfo = ChangesInfo() + public val NO_CHANGES: CompilationResult = CompilationResult() } - public fun plus(other: ChangesInfo): ChangesInfo = - ChangesInfo(protoChanged || other.protoChanged, + public fun plus(other: CompilationResult): CompilationResult = + CompilationResult(protoChanged || other.protoChanged, constantsChanged || other.constantsChanged, inlineChanged || other.inlineChanged, inlineAdded || other.inlineAdded,