diff --git a/.idea/artifacts/KotlinJpsPlugin.xml b/.idea/artifacts/KotlinJpsPlugin.xml index 339fcff5cfc..d20c1520000 100644 --- a/.idea/artifacts/KotlinJpsPlugin.xml +++ b/.idea/artifacts/KotlinJpsPlugin.xml @@ -24,6 +24,7 @@ + \ No newline at end of file diff --git a/.idea/modules.xml b/.idea/modules.xml index 2a0c2319c7a..647e0d006fd 100644 --- a/.idea/modules.xml +++ b/.idea/modules.xml @@ -13,6 +13,7 @@ + diff --git a/build/build.iml b/build/build.iml new file mode 100644 index 00000000000..00fa174c223 --- /dev/null +++ b/build/build.iml @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/build/src/org/jetbrains/kotlin/build/generatedFiles.kt b/build/src/org/jetbrains/kotlin/build/generatedFiles.kt new file mode 100644 index 00000000000..e93777d96d1 --- /dev/null +++ b/build/src/org/jetbrains/kotlin/build/generatedFiles.kt @@ -0,0 +1,40 @@ +/* + * Copyright 2010-2015 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.kotlin.build + +import org.jetbrains.kotlin.incremental.LocalFileKotlinClass +import org.jetbrains.kotlin.load.kotlin.ModuleMapping +import org.jetbrains.kotlin.utils.sure +import java.io.File + +open class GeneratedFile( + val target: Target, + val sourceFiles: Collection, + val outputFile: File +) + +class GeneratedJvmClass ( + target: Target, + sourceFiles: Collection, + outputFile: File +) : GeneratedFile(target, sourceFiles, outputFile) { + val outputClass = LocalFileKotlinClass.create(outputFile).sure { + "Couldn't load KotlinClass from $outputFile; it may happen because class doesn't have valid Kotlin annotations" + } +} + +fun File.isModuleMappingFile() = extension == ModuleMapping.MAPPING_FILE_EXT && parentFile.name == "META-INF" diff --git a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/CacheVersion.kt b/build/src/org/jetbrains/kotlin/incremental/CacheVersion.kt similarity index 56% rename from jps-plugin/src/org/jetbrains/kotlin/jps/incremental/CacheVersion.kt rename to build/src/org/jetbrains/kotlin/incremental/CacheVersion.kt index a2abb79eceb..f66a90e1c7d 100644 --- a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/CacheVersion.kt +++ b/build/src/org/jetbrains/kotlin/incremental/CacheVersion.kt @@ -14,14 +14,10 @@ * limitations under the License. */ -package org.jetbrains.kotlin.jps.incremental +package org.jetbrains.kotlin.incremental import org.jetbrains.annotations.TestOnly -import org.jetbrains.jps.builders.BuildTarget -import org.jetbrains.jps.builders.storage.BuildDataPaths -import org.jetbrains.jps.incremental.ModuleBuildTarget import org.jetbrains.kotlin.config.IncrementalCompilation -import org.jetbrains.kotlin.jps.incremental.CacheVersion.Action import org.jetbrains.kotlin.load.java.JvmBytecodeBinaryVersion import org.jetbrains.kotlin.load.kotlin.JvmMetadataVersion import java.io.File @@ -93,43 +89,38 @@ class CacheVersion( } } -class CacheVersionProvider(private val paths: BuildDataPaths) { - private val BuildTarget<*>.dataRoot: File - get() = paths.getTargetDataRoot(this) +fun normalCacheVersion(dataRoot: File): CacheVersion = + CacheVersion(ownVersion = NORMAL_VERSION, + versionFile = File(dataRoot, NORMAL_VERSION_FILE_NAME), + whenVersionChanged = CacheVersion.Action.REBUILD_CHUNK, + whenTurnedOn = CacheVersion.Action.REBUILD_CHUNK, + whenTurnedOff = CacheVersion.Action.CLEAN_NORMAL_CACHES, + isEnabled = { IncrementalCompilation.isEnabled() }) - fun normalVersion(target: ModuleBuildTarget): CacheVersion = - CacheVersion(ownVersion = NORMAL_VERSION, - versionFile = File(target.dataRoot, NORMAL_VERSION_FILE_NAME), - whenVersionChanged = Action.REBUILD_CHUNK, - whenTurnedOn = Action.REBUILD_CHUNK, - whenTurnedOff = Action.CLEAN_NORMAL_CACHES, - isEnabled = { IncrementalCompilation.isEnabled() }) +fun experimentalCacheVersion(dataRoot: File): CacheVersion = + CacheVersion(ownVersion = EXPERIMENTAL_VERSION, + versionFile = File(dataRoot, EXPERIMENTAL_VERSION_FILE_NAME), + whenVersionChanged = CacheVersion.Action.REBUILD_CHUNK, + whenTurnedOn = CacheVersion.Action.REBUILD_CHUNK, + whenTurnedOff = CacheVersion.Action.CLEAN_EXPERIMENTAL_CACHES, + isEnabled = { IncrementalCompilation.isExperimental() }) - fun experimentalVersion(target: ModuleBuildTarget): CacheVersion = - CacheVersion(ownVersion = EXPERIMENTAL_VERSION, - versionFile = File(target.dataRoot, EXPERIMENTAL_VERSION_FILE_NAME), - whenVersionChanged = Action.REBUILD_CHUNK, - whenTurnedOn = Action.REBUILD_CHUNK, - whenTurnedOff = Action.CLEAN_EXPERIMENTAL_CACHES, - isEnabled = { IncrementalCompilation.isExperimental() }) +fun dataContainerCacheVersion(dataRoot: File): CacheVersion = + CacheVersion(ownVersion = DATA_CONTAINER_VERSION, + versionFile = File(dataRoot, DATA_CONTAINER_VERSION_FILE_NAME), + whenVersionChanged = CacheVersion.Action.REBUILD_ALL_KOTLIN, + whenTurnedOn = CacheVersion.Action.REBUILD_ALL_KOTLIN, + whenTurnedOff = CacheVersion.Action.CLEAN_DATA_CONTAINER, + isEnabled = { IncrementalCompilation.isExperimental() }) - fun dataContainerVersion(): CacheVersion = - CacheVersion(ownVersion = DATA_CONTAINER_VERSION, - versionFile = File(KotlinDataContainerTarget.dataRoot, DATA_CONTAINER_VERSION_FILE_NAME), - whenVersionChanged = Action.REBUILD_ALL_KOTLIN, - whenTurnedOn = Action.REBUILD_ALL_KOTLIN, - whenTurnedOff = Action.CLEAN_DATA_CONTAINER, - isEnabled = { IncrementalCompilation.isExperimental() }) +fun allCachesVersions(containerDataRoot: File, dataRoots: Iterable): Iterable { + val versions = arrayListOf() + versions.add(dataContainerCacheVersion(containerDataRoot)) - fun allVersions(targets: Iterable): Iterable { - val versions = arrayListOf() - versions.add(dataContainerVersion()) - - for (target in targets) { - versions.add(normalVersion(target)) - versions.add(experimentalVersion(target)) - } - - return versions + for (dataRoot in dataRoots) { + versions.add(normalCacheVersion(dataRoot)) + versions.add(experimentalCacheVersion(dataRoot)) } -} \ No newline at end of file + + return versions +} diff --git a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/IncrementalCacheImpl.kt b/build/src/org/jetbrains/kotlin/incremental/IncrementalCacheImpl.kt similarity index 93% rename from jps-plugin/src/org/jetbrains/kotlin/jps/incremental/IncrementalCacheImpl.kt rename to build/src/org/jetbrains/kotlin/incremental/IncrementalCacheImpl.kt index 5b4157eab37..d0f17f43181 100644 --- a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/IncrementalCacheImpl.kt +++ b/build/src/org/jetbrains/kotlin/incremental/IncrementalCacheImpl.kt @@ -14,7 +14,7 @@ * limitations under the License. */ -package org.jetbrains.kotlin.jps.incremental +package org.jetbrains.kotlin.incremental import com.google.protobuf.MessageLite import com.intellij.openapi.util.io.FileUtil.toSystemIndependentName @@ -22,13 +22,9 @@ import com.intellij.util.SmartList import com.intellij.util.io.BooleanDataDescriptor import com.intellij.util.io.EnumeratorStringDescriptor import org.jetbrains.annotations.TestOnly -import org.jetbrains.jps.builders.storage.BuildDataPaths -import org.jetbrains.jps.incremental.ModuleBuildTarget -import org.jetbrains.jps.incremental.storage.PathStringDescriptor +import org.jetbrains.kotlin.build.GeneratedJvmClass import org.jetbrains.kotlin.config.IncrementalCompilation -import org.jetbrains.kotlin.jps.build.GeneratedJvmClass -import org.jetbrains.kotlin.jps.build.KotlinBuilder -import org.jetbrains.kotlin.jps.incremental.storage.* +import org.jetbrains.kotlin.incremental.storage.* import org.jetbrains.kotlin.load.kotlin.ModuleMapping import org.jetbrains.kotlin.load.kotlin.header.KotlinClassHeader import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCache @@ -51,9 +47,10 @@ import java.util.* val KOTLIN_CACHE_DIRECTORY_NAME = "kotlin" -open class IncrementalCacheImpl( - private val target: ModuleBuildTarget, - paths: BuildDataPaths +open class IncrementalCacheImpl( + private val targetDataRoot: File, + targetOutputDir: File?, + target: Target ) : BasicMapsOwner(), IncrementalCache { companion object { private val PROTO_MAP = "proto" @@ -69,8 +66,7 @@ open class IncrementalCacheImpl( private val MODULE_MAPPING_FILE_NAME = "." + ModuleMapping.MAPPING_FILE_EXT } - private val baseDir = File(paths.getTargetDataRoot(target), KOTLIN_CACHE_DIRECTORY_NAME) - private val cacheVersionProvider = CacheVersionProvider(paths) + private val baseDir = File(targetDataRoot, KOTLIN_CACHE_DIRECTORY_NAME) private val experimentalMaps = arrayListOf>() private fun > registerExperimentalMap(map: M): M { @@ -91,19 +87,22 @@ open class IncrementalCacheImpl( private val subtypesMap = registerExperimentalMap(SubtypesMap(SUBTYPES.storageFile)) private val supertypesMap = registerExperimentalMap(SupertypesMap(SUPERTYPES.storageFile)) - private val dependents = arrayListOf() - private val outputDir by lazy(LazyThreadSafetyMode.NONE) { requireNotNull(target.outputDir) { "Target is expected to have output directory: $target" } } + private val dependents = arrayListOf>() + private val outputDir by lazy(LazyThreadSafetyMode.NONE) { requireNotNull(targetOutputDir) { "Target is expected to have output directory: $target" } } - protected val dependentsWithThis: Sequence + // TODO: review + val dependentsWithThis: Sequence> get() = sequenceOf(this).plus(dependents.asSequence()) - internal val dependentCaches: Iterable + internal val dependentCaches: Iterable> get() = dependents override fun registerInline(fromPath: String, jvmSignature: String, toPath: String) { } - fun addDependentCache(cache: IncrementalCacheImpl) { + protected open fun debugLog(message: String) {} + + fun addDependentCache(cache: IncrementalCacheImpl) { dependents.add(cache) } @@ -133,7 +132,7 @@ open class IncrementalCacheImpl( return CompilationResult.NO_CHANGES } - fun saveFileToCache(generatedClass: GeneratedJvmClass): CompilationResult { + fun saveFileToCache(generatedClass: GeneratedJvmClass): CompilationResult { val sourceFiles: Collection = generatedClass.sourceFiles val kotlinClass: LocalFileKotlinClass = generatedClass.outputClass val className = kotlinClass.className @@ -199,7 +198,7 @@ open class IncrementalCacheImpl( private fun CompilationResult.logIfSomethingChanged(className: JvmClassName) { if (this == CompilationResult.NO_CHANGES) return - KotlinBuilder.LOG.debug("$className is changed: $this") + debugLog("$className is changed: $this") } fun clearCacheForRemovedClasses(): CompilationResult { @@ -301,7 +300,7 @@ open class IncrementalCacheImpl( override fun getObsoletePackageParts(): Collection { val obsoletePackageParts = dirtyOutputClassesMap.getDirtyOutputClasses().filter { packagePartMap.isPackagePart(JvmClassName.byInternalName(it)) } - KotlinBuilder.LOG.debug("Obsolete package parts: ${obsoletePackageParts}") + debugLog("Obsolete package parts: ${obsoletePackageParts}") return obsoletePackageParts } @@ -317,7 +316,7 @@ open class IncrementalCacheImpl( val dirtyFacade = partToMultifileFacade.get(dirtyClass) ?: continue obsoleteMultifileClasses.add(dirtyFacade) } - KotlinBuilder.LOG.debug("Obsolete multifile class facades: $obsoleteMultifileClasses") + debugLog("Obsolete multifile class facades: $obsoleteMultifileClasses") return obsoleteMultifileClasses } @@ -336,12 +335,12 @@ open class IncrementalCacheImpl( override fun clean() { super.clean() - cacheVersionProvider.normalVersion(target).clean() - cacheVersionProvider.experimentalVersion(target).clean() + normalCacheVersion(targetDataRoot).clean() + experimentalCacheVersion(targetDataRoot).clean() } fun cleanExperimental() { - cacheVersionProvider.experimentalVersion(target).clean() + experimentalCacheVersion(targetDataRoot).clean() experimentalMaps.forEach { it.clean() } } @@ -497,7 +496,8 @@ open class IncrementalCacheImpl( override fun dumpValue(value: String): String = value } - private inner class SourceToClassesMap(storageFile: File) : BasicStringMap>(storageFile, PathStringDescriptor.INSTANCE, StringCollectionExternalizer) { + // TODO: find how to deal with PathStringDescriptor - it seems too deeply rooted in jps + inner class SourceToClassesMap(storageFile: File) : BasicStringMap>(storageFile, /* PathStringDescriptor.INSTANCE,*/ StringCollectionExternalizer) { fun clearOutputsForSource(sourceFile: File) { remove(sourceFile.absolutePath) } @@ -614,10 +614,10 @@ data class CompilationResult( operator fun plus(other: CompilationResult): CompilationResult = CompilationResult(protoChanged || other.protoChanged, - constantsChanged || other.constantsChanged, - inlineChanged || other.inlineChanged, - inlineAdded || other.inlineAdded, - changes + other.changes) + constantsChanged || other.constantsChanged, + inlineChanged || other.inlineChanged, + inlineAdded || other.inlineAdded, + changes + other.changes) } fun ByteArray.md5(): Long { diff --git a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/IncrementalCompilationComponentsImpl.kt b/build/src/org/jetbrains/kotlin/incremental/IncrementalCompilationComponentsImpl.kt similarity index 82% rename from jps-plugin/src/org/jetbrains/kotlin/jps/incremental/IncrementalCompilationComponentsImpl.kt rename to build/src/org/jetbrains/kotlin/incremental/IncrementalCompilationComponentsImpl.kt index 7214001281f..80fd85a86c5 100644 --- a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/IncrementalCompilationComponentsImpl.kt +++ b/build/src/org/jetbrains/kotlin/incremental/IncrementalCompilationComponentsImpl.kt @@ -14,22 +14,19 @@ * limitations under the License. */ -package org.jetbrains.kotlin.jps.incremental +package org.jetbrains.kotlin.incremental -import org.jetbrains.jps.incremental.ModuleBuildTarget import org.jetbrains.kotlin.incremental.components.LookupTracker import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCache import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCompilationComponents import org.jetbrains.kotlin.modules.TargetId class IncrementalCompilationComponentsImpl( - caches: Map, + private val caches: Map, private val lookupTracker: LookupTracker ): IncrementalCompilationComponents { - private val caches = caches.mapKeys { TargetId(it.key) } - override fun getIncrementalCache(target: TargetId): IncrementalCache = - caches[target]!! + caches[target] ?: throw Exception("Incremental cache for target ${target.name} not found") override fun getLookupTracker(): LookupTracker = lookupTracker } diff --git a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/LocalFileKotlinClass.kt b/build/src/org/jetbrains/kotlin/incremental/LocalFileKotlinClass.kt similarity index 97% rename from jps-plugin/src/org/jetbrains/kotlin/jps/incremental/LocalFileKotlinClass.kt rename to build/src/org/jetbrains/kotlin/incremental/LocalFileKotlinClass.kt index 356b58443eb..e94c8a3c101 100644 --- a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/LocalFileKotlinClass.kt +++ b/build/src/org/jetbrains/kotlin/incremental/LocalFileKotlinClass.kt @@ -14,7 +14,7 @@ * limitations under the License. */ -package org.jetbrains.kotlin.jps.incremental +package org.jetbrains.kotlin.incremental import org.jetbrains.kotlin.load.kotlin.FileBasedKotlinClass import org.jetbrains.kotlin.load.kotlin.header.KotlinClassHeader diff --git a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/LookupStorage.kt b/build/src/org/jetbrains/kotlin/incremental/LookupStorage.kt similarity index 93% rename from jps-plugin/src/org/jetbrains/kotlin/jps/incremental/LookupStorage.kt rename to build/src/org/jetbrains/kotlin/incremental/LookupStorage.kt index 27110d361d1..e1ca3696acf 100644 --- a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/LookupStorage.kt +++ b/build/src/org/jetbrains/kotlin/incremental/LookupStorage.kt @@ -14,24 +14,20 @@ * limitations under the License. */ -package org.jetbrains.kotlin.jps.incremental +package org.jetbrains.kotlin.incremental import com.intellij.util.containers.MultiMap import org.jetbrains.annotations.TestOnly -import org.jetbrains.jps.builders.storage.StorageProvider import org.jetbrains.kotlin.incremental.components.LookupTracker import org.jetbrains.kotlin.incremental.components.Position import org.jetbrains.kotlin.incremental.components.ScopeKind -import org.jetbrains.kotlin.jps.incremental.storage.* +import org.jetbrains.kotlin.incremental.storage.* import org.jetbrains.kotlin.utils.Printer import java.io.File import java.util.* -object LookupStorageProvider : StorageProvider() { - override fun createStorage(targetDataDir: File): LookupStorage = LookupStorage(targetDataDir) -} -class LookupStorage(private val targetDataDir: File) : BasicMapsOwner() { +open class LookupStorage(private val targetDataDir: File) : BasicMapsOwner() { companion object { private val DELETED_TO_SIZE_TRESHOLD = 0.5 private val MINIMUM_GARBAGE_COLLECTIBLE_SIZE = 10000 diff --git a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/ProtoCompareGenerated.kt b/build/src/org/jetbrains/kotlin/incremental/ProtoCompareGenerated.kt similarity index 99% rename from jps-plugin/src/org/jetbrains/kotlin/jps/incremental/ProtoCompareGenerated.kt rename to build/src/org/jetbrains/kotlin/incremental/ProtoCompareGenerated.kt index e09d74d90ab..bc11e1a0b0d 100644 --- a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/ProtoCompareGenerated.kt +++ b/build/src/org/jetbrains/kotlin/incremental/ProtoCompareGenerated.kt @@ -14,7 +14,7 @@ * limitations under the License. */ -package org.jetbrains.kotlin.jps.incremental +package org.jetbrains.kotlin.incremental import org.jetbrains.kotlin.name.ClassId import org.jetbrains.kotlin.serialization.ProtoBuf diff --git a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/protoDifferenceUtils.kt b/build/src/org/jetbrains/kotlin/incremental/protoDifferenceUtils.kt similarity index 97% rename from jps-plugin/src/org/jetbrains/kotlin/jps/incremental/protoDifferenceUtils.kt rename to build/src/org/jetbrains/kotlin/incremental/protoDifferenceUtils.kt index 3f7971857ad..273024b2ec7 100644 --- a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/protoDifferenceUtils.kt +++ b/build/src/org/jetbrains/kotlin/incremental/protoDifferenceUtils.kt @@ -14,13 +14,13 @@ * limitations under the License. */ -package org.jetbrains.kotlin.jps.incremental +package org.jetbrains.kotlin.incremental import com.google.protobuf.MessageLite import org.jetbrains.kotlin.descriptors.Visibilities -import org.jetbrains.kotlin.jps.incremental.ProtoCompareGenerated.ProtoBufClassKind -import org.jetbrains.kotlin.jps.incremental.ProtoCompareGenerated.ProtoBufPackageKind -import org.jetbrains.kotlin.jps.incremental.storage.ProtoMapValue +import org.jetbrains.kotlin.incremental.ProtoCompareGenerated.ProtoBufClassKind +import org.jetbrains.kotlin.incremental.ProtoCompareGenerated.ProtoBufPackageKind +import org.jetbrains.kotlin.incremental.storage.ProtoMapValue import org.jetbrains.kotlin.serialization.Flags import org.jetbrains.kotlin.serialization.ProtoBuf import org.jetbrains.kotlin.serialization.deserialization.Deserialization diff --git a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/storage/BasicMap.kt b/build/src/org/jetbrains/kotlin/incremental/storage/BasicMap.kt similarity index 93% rename from jps-plugin/src/org/jetbrains/kotlin/jps/incremental/storage/BasicMap.kt rename to build/src/org/jetbrains/kotlin/incremental/storage/BasicMap.kt index d2ba1c11631..ef3f7e0c6f7 100644 --- a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/storage/BasicMap.kt +++ b/build/src/org/jetbrains/kotlin/incremental/storage/BasicMap.kt @@ -14,7 +14,7 @@ * limitations under the License. */ -package org.jetbrains.kotlin.jps.incremental.storage +package org.jetbrains.kotlin.incremental.storage import com.intellij.util.io.DataExternalizer import com.intellij.util.io.EnumeratorStringDescriptor @@ -23,7 +23,7 @@ import org.jetbrains.annotations.TestOnly import org.jetbrains.kotlin.utils.Printer import java.io.File -internal abstract class BasicMap, V>( +abstract class BasicMap, V>( storageFile: File, keyDescriptor: KeyDescriptor, valueExternalizer: DataExternalizer @@ -67,7 +67,7 @@ internal abstract class BasicMap, V>( protected abstract fun dumpValue(value: V): String } -internal abstract class BasicStringMap( +abstract class BasicStringMap( storageFile: File, keyDescriptor: KeyDescriptor, valueExternalizer: DataExternalizer @@ -78,4 +78,4 @@ internal abstract class BasicStringMap( ) : this(storageFile, EnumeratorStringDescriptor.INSTANCE, valueExternalizer) override fun dumpKey(key: String): String = key -} \ No newline at end of file +} diff --git a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/storage/BasicMapsOwner.kt b/build/src/org/jetbrains/kotlin/incremental/storage/BasicMapsOwner.kt similarity index 81% rename from jps-plugin/src/org/jetbrains/kotlin/jps/incremental/storage/BasicMapsOwner.kt rename to build/src/org/jetbrains/kotlin/incremental/storage/BasicMapsOwner.kt index 6e11fb22d50..5cc5cc28fae 100644 --- a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/storage/BasicMapsOwner.kt +++ b/build/src/org/jetbrains/kotlin/incremental/storage/BasicMapsOwner.kt @@ -14,12 +14,11 @@ * limitations under the License. */ -package org.jetbrains.kotlin.jps.incremental.storage +package org.jetbrains.kotlin.incremental.storage import org.jetbrains.annotations.TestOnly -import org.jetbrains.jps.incremental.storage.StorageOwner -open class BasicMapsOwner : StorageOwner { +open class BasicMapsOwner { private val maps = arrayListOf>() companion object { @@ -31,15 +30,15 @@ open class BasicMapsOwner : StorageOwner { return map } - override fun clean() { + open fun clean() { maps.forEach { it.clean() } } - override fun close() { + open fun close() { maps.forEach { it.close() } } - override fun flush(memoryCachesOnly: Boolean) { + open fun flush(memoryCachesOnly: Boolean) { maps.forEach { it.flush(memoryCachesOnly) } } diff --git a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/storage/ClassOneToManyMap.kt b/build/src/org/jetbrains/kotlin/incremental/storage/ClassOneToManyMap.kt similarity index 93% rename from jps-plugin/src/org/jetbrains/kotlin/jps/incremental/storage/ClassOneToManyMap.kt rename to build/src/org/jetbrains/kotlin/incremental/storage/ClassOneToManyMap.kt index b04477bf682..e70f4b3a469 100644 --- a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/storage/ClassOneToManyMap.kt +++ b/build/src/org/jetbrains/kotlin/incremental/storage/ClassOneToManyMap.kt @@ -14,9 +14,9 @@ * limitations under the License. */ -package org.jetbrains.kotlin.jps.incremental.storage +package org.jetbrains.kotlin.incremental.storage -import org.jetbrains.kotlin.jps.incremental.dumpCollection +import org.jetbrains.kotlin.incremental.dumpCollection import org.jetbrains.kotlin.name.FqName import java.io.File diff --git a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/storage/FileToIdMap.kt b/build/src/org/jetbrains/kotlin/incremental/storage/FileToIdMap.kt similarity index 95% rename from jps-plugin/src/org/jetbrains/kotlin/jps/incremental/storage/FileToIdMap.kt rename to build/src/org/jetbrains/kotlin/incremental/storage/FileToIdMap.kt index fdae86816b5..90abe12b22d 100644 --- a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/storage/FileToIdMap.kt +++ b/build/src/org/jetbrains/kotlin/incremental/storage/FileToIdMap.kt @@ -14,7 +14,7 @@ * limitations under the License. */ -package org.jetbrains.kotlin.jps.incremental.storage +package org.jetbrains.kotlin.incremental.storage import org.jetbrains.kotlin.utils.keysToMap import java.io.File diff --git a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/storage/IdToFileMap.kt b/build/src/org/jetbrains/kotlin/incremental/storage/IdToFileMap.kt similarity index 95% rename from jps-plugin/src/org/jetbrains/kotlin/jps/incremental/storage/IdToFileMap.kt rename to build/src/org/jetbrains/kotlin/incremental/storage/IdToFileMap.kt index cd6ce62bc4e..98f84e01d43 100644 --- a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/storage/IdToFileMap.kt +++ b/build/src/org/jetbrains/kotlin/incremental/storage/IdToFileMap.kt @@ -14,7 +14,7 @@ * limitations under the License. */ -package org.jetbrains.kotlin.jps.incremental.storage +package org.jetbrains.kotlin.incremental.storage import com.intellij.util.io.ExternalIntegerKeyDescriptor import java.io.File diff --git a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/storage/LazyStorage.kt b/build/src/org/jetbrains/kotlin/incremental/storage/LazyStorage.kt similarity index 97% rename from jps-plugin/src/org/jetbrains/kotlin/jps/incremental/storage/LazyStorage.kt rename to build/src/org/jetbrains/kotlin/incremental/storage/LazyStorage.kt index 0a5690c8c41..55eddd43592 100644 --- a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/storage/LazyStorage.kt +++ b/build/src/org/jetbrains/kotlin/incremental/storage/LazyStorage.kt @@ -14,7 +14,7 @@ * limitations under the License. */ -package org.jetbrains.kotlin.jps.incremental.storage +package org.jetbrains.kotlin.incremental.storage import com.intellij.util.io.DataExternalizer import com.intellij.util.io.IOUtil @@ -28,7 +28,7 @@ import java.io.IOException /** * It's lazy in a sense that PersistentHashMap is created only on write */ -internal class LazyStorage( +class LazyStorage( private val storageFile: File, private val keyDescriptor: KeyDescriptor, private val valueExternalizer: DataExternalizer diff --git a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/storage/LookupMap.kt b/build/src/org/jetbrains/kotlin/incremental/storage/LookupMap.kt similarity index 96% rename from jps-plugin/src/org/jetbrains/kotlin/jps/incremental/storage/LookupMap.kt rename to build/src/org/jetbrains/kotlin/incremental/storage/LookupMap.kt index 70fe113bf72..d9fab23228b 100644 --- a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/storage/LookupMap.kt +++ b/build/src/org/jetbrains/kotlin/incremental/storage/LookupMap.kt @@ -14,7 +14,7 @@ * limitations under the License. */ -package org.jetbrains.kotlin.jps.incremental.storage +package org.jetbrains.kotlin.incremental.storage import java.io.File diff --git a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/storage/externalizers.kt b/build/src/org/jetbrains/kotlin/incremental/storage/externalizers.kt similarity index 92% rename from jps-plugin/src/org/jetbrains/kotlin/jps/incremental/storage/externalizers.kt rename to build/src/org/jetbrains/kotlin/incremental/storage/externalizers.kt index 39acab1e1de..fa9ebe38efc 100644 --- a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/storage/externalizers.kt +++ b/build/src/org/jetbrains/kotlin/incremental/storage/externalizers.kt @@ -14,7 +14,7 @@ * limitations under the License. */ -package org.jetbrains.kotlin.jps.incremental.storage +package org.jetbrains.kotlin.incremental.storage import com.intellij.openapi.util.io.FileUtil import com.intellij.util.io.DataExternalizer @@ -22,7 +22,6 @@ import com.intellij.util.io.EnumeratorStringDescriptor import com.intellij.util.io.IOUtil import com.intellij.util.io.KeyDescriptor import gnu.trove.THashSet -import org.jetbrains.jps.incremental.storage.PathStringDescriptor import java.io.DataInput import java.io.DataInputStream import java.io.DataOutput @@ -125,6 +124,27 @@ object StringToLongMapExternalizer : StringMapExternalizer() { } } + +object PathStringCollectionExternalizer : DataExternalizer> { + override fun save(output: DataOutput, value: Collection) { + for (str in value) { + IOUtil.writeUTF(output, str) + } + } + + override fun read(input: DataInput): Collection { + val result = THashSet(FileUtil.PATH_HASHING_STRATEGY) + val stream = input as DataInputStream + + while (stream.available() > 0) { + val str = IOUtil.readUTF(stream) + result.add(str) + } + + return result + } +} + object ConstantsMapExternalizer : DataExternalizer> { override fun save(output: DataOutput, map: Map?) { output.writeInt(map!!.size) @@ -228,6 +248,4 @@ open class CollectionExternalizer( object StringCollectionExternalizer : CollectionExternalizer(EnumeratorStringDescriptor(), { HashSet() }) -object PathCollectionExternalizer : CollectionExternalizer(PathStringDescriptor(), { THashSet(FileUtil.PATH_HASHING_STRATEGY) }) - object IntCollectionExternalizer : CollectionExternalizer(IntExternalizer, { HashSet() }) diff --git a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/storage/values.kt b/build/src/org/jetbrains/kotlin/incremental/storage/values.kt similarity index 97% rename from jps-plugin/src/org/jetbrains/kotlin/jps/incremental/storage/values.kt rename to build/src/org/jetbrains/kotlin/incremental/storage/values.kt index 986415f3d61..c86500b7fd0 100644 --- a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/storage/values.kt +++ b/build/src/org/jetbrains/kotlin/incremental/storage/values.kt @@ -14,7 +14,7 @@ * limitations under the License. */ -package org.jetbrains.kotlin.jps.incremental.storage +package org.jetbrains.kotlin.incremental.storage import com.intellij.openapi.util.io.FileUtil diff --git a/generators/src/org/jetbrains/kotlin/generators/protobuf/GenerateProtoBufCompare.kt b/generators/src/org/jetbrains/kotlin/generators/protobuf/GenerateProtoBufCompare.kt index f71b2615731..2679ddc43b9 100644 --- a/generators/src/org/jetbrains/kotlin/generators/protobuf/GenerateProtoBufCompare.kt +++ b/generators/src/org/jetbrains/kotlin/generators/protobuf/GenerateProtoBufCompare.kt @@ -27,7 +27,7 @@ import java.util.* class GenerateProtoBufCompare { companion object { - val DEST_FILE: File = File("jps-plugin/src/org/jetbrains/kotlin/jps/incremental/ProtoCompareGenerated.kt") + val DEST_FILE: File = File("build/src/org/jetbrains/kotlin/incremental/ProtoCompareGenerated.kt") @JvmStatic fun main(args: Array) { @@ -70,7 +70,7 @@ class GenerateProtoBufCompare { val sb = StringBuilder() val p = Printer(sb) p.println(File("license/LICENSE.txt").readText()) - p.println("package org.jetbrains.kotlin.jps.incremental") + p.println("package org.jetbrains.kotlin.incremental") p.println() p.println("import org.jetbrains.kotlin.name.ClassId") diff --git a/jps-plugin/jps-plugin.iml b/jps-plugin/jps-plugin.iml index 69920e17ed0..09a0ac0fec2 100644 --- a/jps-plugin/jps-plugin.iml +++ b/jps-plugin/jps-plugin.iml @@ -10,6 +10,7 @@ + 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 edcfde1f205..a0c2c725afa 100644 --- a/jps-plugin/src/org/jetbrains/kotlin/jps/build/KotlinBuilder.kt +++ b/jps-plugin/src/org/jetbrains/kotlin/jps/build/KotlinBuilder.kt @@ -39,6 +39,9 @@ import org.jetbrains.jps.model.ex.JpsElementChildRoleBase import org.jetbrains.jps.model.java.JpsJavaClasspathKind import org.jetbrains.jps.model.java.JpsJavaExtensionService import org.jetbrains.jps.model.module.JpsModule +import org.jetbrains.kotlin.build.GeneratedFile +import org.jetbrains.kotlin.build.GeneratedJvmClass +import org.jetbrains.kotlin.build.isModuleMappingFile import org.jetbrains.kotlin.cli.common.KotlinVersion import org.jetbrains.kotlin.cli.common.arguments.CommonCompilerArguments import org.jetbrains.kotlin.cli.common.messages.CompilerMessageLocation @@ -54,10 +57,10 @@ import org.jetbrains.kotlin.config.CompilerRunnerConstants.INTERNAL_ERROR_PREFIX import org.jetbrains.kotlin.config.IncrementalCompilation import org.jetbrains.kotlin.config.Services import org.jetbrains.kotlin.daemon.common.isDaemonEnabled +import org.jetbrains.kotlin.incremental.* import org.jetbrains.kotlin.incremental.components.LookupTracker import org.jetbrains.kotlin.jps.JpsKotlinCompilerSettings import org.jetbrains.kotlin.jps.incremental.* -import org.jetbrains.kotlin.load.kotlin.ModuleMapping import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCache import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCompilationComponents import org.jetbrains.kotlin.modules.TargetId @@ -67,7 +70,6 @@ import org.jetbrains.kotlin.progress.CompilationCanceledStatus import org.jetbrains.kotlin.utils.JsLibraryUtils import org.jetbrains.kotlin.utils.PathUtil import org.jetbrains.kotlin.utils.keysToMap -import org.jetbrains.kotlin.utils.sure import org.jetbrains.org.objectweb.asm.ClassReader import java.io.File import java.util.* @@ -249,7 +251,7 @@ class KotlinBuilder : ModuleLevelBuilder(BuilderCategory.SOURCE_PROCESSOR) { return OK } - val generatedClasses = generatedFiles.filterIsInstance() + val generatedClasses = generatedFiles.filterIsInstance>() updateJavaMappings(chunk, compilationErrors, context, dirtyFilesHolder, filesToCompile, generatedClasses) if (!IncrementalCompilation.isEnabled()) { @@ -301,7 +303,7 @@ class KotlinBuilder : ModuleLevelBuilder(BuilderCategory.SOURCE_PROCESSOR) { rebuildAfterCacheVersionChanged[target] = true } - dataManager.getStorage(KotlinDataContainerTarget, LookupStorageProvider).clean() + dataManager.getStorage(KotlinDataContainerTarget, JpsLookupStorageProvider).clean() return } CacheVersion.Action.REBUILD_CHUNK -> { @@ -333,7 +335,7 @@ class KotlinBuilder : ModuleLevelBuilder(BuilderCategory.SOURCE_PROCESSOR) { } CacheVersion.Action.CLEAN_DATA_CONTAINER -> { LOG.info("Clearing lookup cache") - dataManager.getStorage(KotlinDataContainerTarget, LookupStorageProvider).clean() + dataManager.getStorage(KotlinDataContainerTarget, JpsLookupStorageProvider).clean() cacheVersionsProvider.dataContainerVersion().clean() } else -> { @@ -353,7 +355,7 @@ class KotlinBuilder : ModuleLevelBuilder(BuilderCategory.SOURCE_PROCESSOR) { private fun doCompileModuleChunk( allCompiledFiles: MutableSet, chunk: ModuleChunk, commonArguments: CommonCompilerArguments, context: CompileContext, dirtyFilesHolder: DirtyFilesHolder, environment: CompilerEnvironment, - filesToCompile: MultiMap, incrementalCaches: Map, + filesToCompile: MultiMap, incrementalCaches: Map>, messageCollector: MessageCollectorAdapter, project: JpsProject ): OutputItemsCollectorImpl? { @@ -398,7 +400,8 @@ class KotlinBuilder : ModuleLevelBuilder(BuilderCategory.SOURCE_PROCESSOR) { context: CompileContext ): CompilerEnvironment { val compilerServices = Services.Builder() - .register(IncrementalCompilationComponents::class.java, IncrementalCompilationComponentsImpl(incrementalCaches, lookupTracker)) + .register(IncrementalCompilationComponents::class.java, + IncrementalCompilationComponentsImpl(incrementalCaches.mapKeys { TargetId(it.key) }, lookupTracker)) .register(CompilationCanceledStatus::class.java, object : CompilationCanceledStatus { override fun checkCanceled() { if (context.cancelStatus.isCanceled) throw CompilationCanceledException() @@ -424,7 +427,7 @@ class KotlinBuilder : ModuleLevelBuilder(BuilderCategory.SOURCE_PROCESSOR) { private fun getGeneratedFiles( chunk: ModuleChunk, outputItemCollector: OutputItemsCollectorImpl - ): List { + ): List> { // If there's only one target, this map is empty: get() always returns null, and the representativeTarget will be used below val sourceToTarget = HashMap() if (chunk.targets.size > 1) { @@ -435,7 +438,7 @@ class KotlinBuilder : ModuleLevelBuilder(BuilderCategory.SOURCE_PROCESSOR) { } } - val result = ArrayList() + val result = ArrayList>() val representativeTarget = chunk.representativeTarget() for (outputItem in outputItemCollector.outputs) { @@ -450,7 +453,7 @@ class KotlinBuilder : ModuleLevelBuilder(BuilderCategory.SOURCE_PROCESSOR) { result.add(GeneratedJvmClass(target, sourceFiles, outputFile)) } else { - result.add(GeneratedFile(target, sourceFiles, outputFile)) + result.add(GeneratedFile(target, sourceFiles, outputFile)) } } return result @@ -462,7 +465,7 @@ class KotlinBuilder : ModuleLevelBuilder(BuilderCategory.SOURCE_PROCESSOR) { context: CompileContext, dirtyFilesHolder: DirtyFilesHolder, filesToCompile: MultiMap, - generatedClasses: List + generatedClasses: List> ) { val previousMappings = context.projectDescriptor.dataManager.mappings val delta = previousMappings.createDelta() @@ -481,7 +484,7 @@ class KotlinBuilder : ModuleLevelBuilder(BuilderCategory.SOURCE_PROCESSOR) { JavaBuilderUtil.updateMappings(context, delta, dirtyFilesHolder, chunk, allCompiled, compiledInThisRound) } - private fun registerOutputItems(outputConsumer: ModuleLevelBuilder.OutputConsumer, generatedFiles: List) { + private fun registerOutputItems(outputConsumer: ModuleLevelBuilder.OutputConsumer, generatedFiles: List>) { for (generatedFile in generatedFiles) { outputConsumer.registerOutputFile(generatedFile.target, generatedFile.outputFile, generatedFile.sourceFiles.map { it.path }) } @@ -489,8 +492,8 @@ class KotlinBuilder : ModuleLevelBuilder(BuilderCategory.SOURCE_PROCESSOR) { private fun updateKotlinIncrementalCache( compilationErrors: Boolean, - incrementalCaches: Map, - generatedFiles: List + incrementalCaches: Map, + generatedFiles: List> ): CompilationResult { assert(IncrementalCompilation.isEnabled()) { "updateKotlinIncrementalCache should not be called when incremental compilation disabled" } @@ -499,7 +502,7 @@ class KotlinBuilder : ModuleLevelBuilder(BuilderCategory.SOURCE_PROCESSOR) { for (generatedFile in generatedFiles) { val ic = incrementalCaches[generatedFile.target]!! val newChangesInfo = - if (generatedFile is GeneratedJvmClass) { + if (generatedFile is GeneratedJvmClass) { ic.saveFileToCache(generatedFile) } else if (generatedFile.outputFile.isModuleMappingFile()) { @@ -533,7 +536,7 @@ class KotlinBuilder : ModuleLevelBuilder(BuilderCategory.SOURCE_PROCESSOR) { if (lookupTracker !is LookupTrackerImpl) throw AssertionError("Lookup tracker is expected to be LookupTrackerImpl, got ${lookupTracker.javaClass}") - val lookupStorage = dataManager.getStorage(KotlinDataContainerTarget, LookupStorageProvider) + val lookupStorage = dataManager.getStorage(KotlinDataContainerTarget, JpsLookupStorageProvider) filesToCompile.values().forEach { lookupStorage.removeLookupsFrom(it) } val removedFiles = chunk.targets.flatMap { KotlinSourceFileCollector.getRemovedKotlinFiles(dirtyFilesHolder, it) } @@ -542,8 +545,6 @@ class KotlinBuilder : ModuleLevelBuilder(BuilderCategory.SOURCE_PROCESSOR) { lookupTracker.lookups.entrySet().forEach { lookupStorage.add(it.key, it.value) } } - private fun File.isModuleMappingFile() = extension == ModuleMapping.MAPPING_FILE_EXT && parentFile.name == "META-INF" - // if null is returned, nothing was done private fun compileToJs(chunk: ModuleChunk, commonArguments: CommonCompilerArguments, @@ -740,12 +741,11 @@ private fun CompilationResult.doProcessChangesUsingLookups( compiledFiles: Set, dataManager: BuildDataManager, fsOperations: FSOperationsHelper, - caches: Collection + caches: Collection> ) { val dirtyLookupSymbols = HashSet() - val lookupStorage = dataManager.getStorage(KotlinDataContainerTarget, LookupStorageProvider) - val allCaches = caches.toHashSet() - allCaches.addAll(caches.flatMap { it.dependentCaches }) + val lookupStorage = dataManager.getStorage(KotlinDataContainerTarget, JpsLookupStorageProvider) + val allCaches: Sequence> = caches.asSequence().flatMap { it.dependentsWithThis } KotlinBuilder.LOG.debug("Start processing changes") @@ -797,7 +797,7 @@ private fun CompilationResult.doProcessChangesUsingLookups( */ private fun withSubtypes( typeFqName: FqName, - caches: Collection + caches: Sequence> ): Set { val types = linkedListOf(typeFqName) val subtypes = hashSetOf() @@ -805,10 +805,9 @@ private fun withSubtypes( while (types.isNotEmpty()) { val unprocessedType = types.pollFirst() - caches.asSequence() - .flatMap { it.getSubtypesOf(unprocessedType) } - .filter { it !in subtypes } - .forEach { types.addLast(it) } + caches.flatMap { it.getSubtypesOf(unprocessedType) } + .filter { it !in subtypes } + .forEach { types.addLast(it) } subtypes.add(unprocessedType) } @@ -915,22 +914,6 @@ private fun hasKotlinDirtyOrRemovedFiles( return chunk.targets.any { KotlinSourceFileCollector.getRemovedKotlinFiles(dirtyFilesHolder, it).isNotEmpty() } } -open class GeneratedFile internal constructor( - val target: ModuleBuildTarget, - val sourceFiles: Collection, - val outputFile: File -) - -class GeneratedJvmClass ( - target: ModuleBuildTarget, - sourceFiles: Collection, - outputFile: File -) : GeneratedFile(target, sourceFiles, outputFile) { - val outputClass = LocalFileKotlinClass.create(outputFile).sure { - "Couldn't load KotlinClass from $outputFile; it may happen because class doesn't have valid Kotlin annotations" - } -} - private inline fun Iterable.forAllPairs(other: Iterable, fn: (T, R)->Unit) { for (t in this) { for (r in other) { diff --git a/jps-plugin/src/org/jetbrains/kotlin/jps/build/MarkerFile.kt b/jps-plugin/src/org/jetbrains/kotlin/jps/build/MarkerFile.kt index 649bbe39177..7f0e8231008 100644 --- a/jps-plugin/src/org/jetbrains/kotlin/jps/build/MarkerFile.kt +++ b/jps-plugin/src/org/jetbrains/kotlin/jps/build/MarkerFile.kt @@ -19,7 +19,7 @@ package org.jetbrains.kotlin.jps.build import org.jetbrains.jps.builders.storage.BuildDataPaths import org.jetbrains.jps.incremental.ModuleBuildTarget import org.jetbrains.jps.incremental.storage.BuildDataManager -import org.jetbrains.kotlin.jps.incremental.KOTLIN_CACHE_DIRECTORY_NAME +import org.jetbrains.kotlin.incremental.KOTLIN_CACHE_DIRECTORY_NAME import java.io.File private val HAS_KOTLIN_MARKER_FILE_NAME = "has-kotlin-marker.txt" diff --git a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/CacheVersionProvider.kt b/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/CacheVersionProvider.kt new file mode 100644 index 00000000000..81652efe9aa --- /dev/null +++ b/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/CacheVersionProvider.kt @@ -0,0 +1,37 @@ +/* + * Copyright 2010-2015 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.kotlin.jps.incremental + +import org.jetbrains.jps.builders.BuildTarget +import org.jetbrains.jps.builders.storage.BuildDataPaths +import org.jetbrains.jps.incremental.ModuleBuildTarget +import org.jetbrains.kotlin.incremental.* +import java.io.File + + +class CacheVersionProvider(private val paths: BuildDataPaths) { + private val BuildTarget<*>.dataRoot: File + get() = paths.getTargetDataRoot(this) + + fun normalVersion(target: ModuleBuildTarget): CacheVersion = normalCacheVersion(target.dataRoot) + + fun experimentalVersion(target: ModuleBuildTarget): CacheVersion = experimentalCacheVersion(target.dataRoot) + + fun dataContainerVersion(): CacheVersion = dataContainerCacheVersion(KotlinDataContainerTarget.dataRoot) + + fun allVersions(targets: Iterable): Iterable = allCachesVersions(KotlinDataContainerTarget.dataRoot, targets.map { it.dataRoot } ) +} \ No newline at end of file diff --git a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/JpsIncrementalCacheImpl.kt b/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/JpsIncrementalCacheImpl.kt index 601e45a2f62..6653b066084 100644 --- a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/JpsIncrementalCacheImpl.kt +++ b/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/JpsIncrementalCacheImpl.kt @@ -24,8 +24,10 @@ import org.jetbrains.jps.incremental.ModuleBuildTarget import org.jetbrains.jps.incremental.storage.BuildDataManager import org.jetbrains.jps.incremental.storage.StorageOwner import org.jetbrains.kotlin.config.IncrementalCompilation +import org.jetbrains.kotlin.incremental.* +import org.jetbrains.kotlin.incremental.storage.* import org.jetbrains.kotlin.inline.inlineFunctionsJvmNames -import org.jetbrains.kotlin.jps.incremental.storage.* +import org.jetbrains.kotlin.jps.build.KotlinBuilder import org.jetbrains.kotlin.resolve.jvm.JvmClassName import org.jetbrains.org.objectweb.asm.* import java.io.File @@ -34,7 +36,7 @@ import java.util.* class JpsIncrementalCacheImpl( target: ModuleBuildTarget, paths: BuildDataPaths -) : IncrementalCacheImpl(target, paths), StorageOwner { +) : IncrementalCacheImpl(paths.getTargetDataRoot(target), target.outputDir, target), StorageOwner { private val inlineFunctionsMap = registerMap(InlineFunctionsMap(INLINE_FUNCTIONS.storageFile)) private val dirtyInlineFunctionsMap = registerMap(DirtyInlineFunctionsMap(DIRTY_INLINE_FUNCTIONS.storageFile)) @@ -46,6 +48,10 @@ class JpsIncrementalCacheImpl( } } + override fun debugLog(message: String) { + KotlinBuilder.LOG.debug(message) + } + override fun additionalProcessChangedClass(kotlinClass: LocalFileKotlinClass, isPackage: Boolean) = inlineFunctionsMap.process(kotlinClass, isPackage) @@ -173,7 +179,7 @@ class JpsIncrementalCacheImpl( * * inlineFunction - jvmSignature of some inline function in source file * * target files - collection of files inlineFunction has been inlined to */ - private inner class InlineFunctionsFilesMap(storageFile: File) : BasicMap>(storageFile, PathFunctionPairKeyDescriptor, PathCollectionExternalizer) { + private inner class InlineFunctionsFilesMap(storageFile: File) : BasicMap>(storageFile, PathFunctionPairKeyDescriptor, PathStringCollectionExternalizer) { fun add(sourcePath: String, jvmSignature: String, targetPath: String) { val key = PathFunctionPair(sourcePath, jvmSignature) storage.append(key, targetPath) diff --git a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/JpsLookupStorage.kt b/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/JpsLookupStorage.kt new file mode 100644 index 00000000000..3268002254b --- /dev/null +++ b/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/JpsLookupStorage.kt @@ -0,0 +1,28 @@ +/* + * Copyright 2010-2015 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.jetbrains.kotlin.jps.incremental + +import org.jetbrains.jps.builders.storage.StorageProvider +import org.jetbrains.jps.incremental.storage.StorageOwner +import org.jetbrains.kotlin.incremental.LookupStorage +import java.io.File + +object JpsLookupStorageProvider : StorageProvider() { + override fun createStorage(targetDataDir: File): JpsLookupStorage = JpsLookupStorage(targetDataDir) +} + +class JpsLookupStorage(targetDataDir: File) : StorageOwner, LookupStorage(targetDataDir) diff --git a/jps-plugin/test/org/jetbrains/kotlin/jps/build/AbstractIncrementalJpsTest.kt b/jps-plugin/test/org/jetbrains/kotlin/jps/build/AbstractIncrementalJpsTest.kt index 37cac8b92db..744871793e7 100644 --- a/jps-plugin/test/org/jetbrains/kotlin/jps/build/AbstractIncrementalJpsTest.kt +++ b/jps-plugin/test/org/jetbrains/kotlin/jps/build/AbstractIncrementalJpsTest.kt @@ -44,11 +44,11 @@ import org.jetbrains.jps.model.java.JpsJavaDependencyScope import org.jetbrains.jps.model.java.JpsJavaExtensionService import org.jetbrains.jps.util.JpsPathUtil import org.jetbrains.kotlin.config.IncrementalCompilation +import org.jetbrains.kotlin.incremental.LookupSymbol import org.jetbrains.kotlin.incremental.components.LookupTracker import org.jetbrains.kotlin.jps.build.classFilesComparison.assertEqualDirectories +import org.jetbrains.kotlin.jps.incremental.JpsLookupStorageProvider import org.jetbrains.kotlin.jps.incremental.KotlinDataContainerTarget -import org.jetbrains.kotlin.jps.incremental.LookupStorageProvider -import org.jetbrains.kotlin.jps.incremental.LookupSymbol import org.jetbrains.kotlin.jps.incremental.getKotlinCache import org.jetbrains.kotlin.test.KotlinTestUtils import org.jetbrains.kotlin.utils.Printer @@ -384,7 +384,7 @@ abstract class AbstractIncrementalJpsTest( p.println("Begin of Lookup Maps") p.println() - val lookupStorage = project.dataManager.getStorage(KotlinDataContainerTarget, LookupStorageProvider) + val lookupStorage = project.dataManager.getStorage(KotlinDataContainerTarget, JpsLookupStorageProvider) lookupStorage.forceGC() p.print(lookupStorage.dump(lookupsDuringTest)) diff --git a/jps-plugin/test/org/jetbrains/kotlin/jps/build/AbstractIncrementalLazyCachesTest.kt b/jps-plugin/test/org/jetbrains/kotlin/jps/build/AbstractIncrementalLazyCachesTest.kt index 2ee10bc107a..9850719ebd1 100644 --- a/jps-plugin/test/org/jetbrains/kotlin/jps/build/AbstractIncrementalLazyCachesTest.kt +++ b/jps-plugin/test/org/jetbrains/kotlin/jps/build/AbstractIncrementalLazyCachesTest.kt @@ -20,11 +20,11 @@ import com.intellij.testFramework.UsefulTestCase import org.jetbrains.jps.builders.BuildTarget import org.jetbrains.jps.builders.storage.BuildDataPaths import org.jetbrains.kotlin.config.IncrementalCompilation -import org.jetbrains.kotlin.jps.incremental.CacheVersion +import org.jetbrains.kotlin.incremental.CacheVersion +import org.jetbrains.kotlin.incremental.storage.BasicMapsOwner import org.jetbrains.kotlin.jps.incremental.CacheVersionProvider -import org.jetbrains.kotlin.jps.incremental.KOTLIN_CACHE_DIRECTORY_NAME +import org.jetbrains.kotlin.incremental.KOTLIN_CACHE_DIRECTORY_NAME import org.jetbrains.kotlin.jps.incremental.KotlinDataContainerTarget -import org.jetbrains.kotlin.jps.incremental.storage.BasicMapsOwner import org.jetbrains.kotlin.utils.Printer import java.io.File @@ -119,4 +119,4 @@ abstract class AbstractIncrementalLazyCachesTest : AbstractIncrementalJpsTest() return result } -} \ No newline at end of file +} diff --git a/jps-plugin/test/org/jetbrains/kotlin/jps/build/classFilesComparison/classFilesComparison.kt b/jps-plugin/test/org/jetbrains/kotlin/jps/build/classFilesComparison/classFilesComparison.kt index ff1accafe69..e2fdf2ca5f5 100644 --- a/jps-plugin/test/org/jetbrains/kotlin/jps/build/classFilesComparison/classFilesComparison.kt +++ b/jps-plugin/test/org/jetbrains/kotlin/jps/build/classFilesComparison/classFilesComparison.kt @@ -21,7 +21,7 @@ import com.google.common.hash.Hashing import com.google.common.io.Files import com.google.protobuf.ExtensionRegistry import com.intellij.openapi.util.io.FileUtil -import org.jetbrains.kotlin.jps.incremental.LocalFileKotlinClass +import org.jetbrains.kotlin.incremental.LocalFileKotlinClass import org.jetbrains.kotlin.load.kotlin.header.KotlinClassHeader import org.jetbrains.kotlin.serialization.DebugProtoBuf import org.jetbrains.kotlin.serialization.jvm.BitEncoding diff --git a/jps-plugin/test/org/jetbrains/kotlin/jps/incremental/AbstractProtoComparisonTest.kt b/jps-plugin/test/org/jetbrains/kotlin/jps/incremental/AbstractProtoComparisonTest.kt index b5664c77f93..922bad39daf 100644 --- a/jps-plugin/test/org/jetbrains/kotlin/jps/incremental/AbstractProtoComparisonTest.kt +++ b/jps-plugin/test/org/jetbrains/kotlin/jps/incremental/AbstractProtoComparisonTest.kt @@ -19,7 +19,9 @@ package org.jetbrains.kotlin.jps.incremental import com.intellij.openapi.util.io.FileUtil import com.intellij.testFramework.UsefulTestCase import com.intellij.util.SmartList -import org.jetbrains.kotlin.jps.incremental.storage.ProtoMapValue +import org.jetbrains.kotlin.incremental.LocalFileKotlinClass +import org.jetbrains.kotlin.incremental.difference +import org.jetbrains.kotlin.incremental.storage.ProtoMapValue import org.jetbrains.kotlin.load.kotlin.KotlinJvmBinaryClass import org.jetbrains.kotlin.load.kotlin.header.KotlinClassHeader import org.jetbrains.kotlin.serialization.jvm.BitEncoding @@ -124,4 +126,4 @@ abstract class AbstractProtoComparisonTest : UsefulTestCase() { FileUtil.createDirectory(directory) return directory } -} \ No newline at end of file +}