From d1fd88fb8e152dc9c3b7a14c8d3c6e3c46d51ab0 Mon Sep 17 00:00:00 2001 From: Alexey Tsvetkov Date: Fri, 30 Jun 2017 04:54:43 +0300 Subject: [PATCH] Minimize usage of TargetId in IC --- .../incremental/IncrementalCacheImpl.kt | 9 +- .../jetbrains/kotlin/incremental/buildUtil.kt | 92 ++----------------- .../incremental/IncrementalCachesManager.kt | 4 +- .../IncrementalJvmCompilerRunner.kt | 33 ++++--- .../kotlin/jps/build/KotlinBuilder.kt | 4 +- .../incremental/JpsIncrementalCacheImpl.kt | 2 +- 6 files changed, 34 insertions(+), 110 deletions(-) diff --git a/build-common/src/org/jetbrains/kotlin/incremental/IncrementalCacheImpl.kt b/build-common/src/org/jetbrains/kotlin/incremental/IncrementalCacheImpl.kt index 9728c7fbbe1..39d68cd749a 100644 --- a/build-common/src/org/jetbrains/kotlin/incremental/IncrementalCacheImpl.kt +++ b/build-common/src/org/jetbrains/kotlin/incremental/IncrementalCacheImpl.kt @@ -47,10 +47,9 @@ import java.util.* val KOTLIN_CACHE_DIRECTORY_NAME = "kotlin" -open class IncrementalCacheImpl( +open class IncrementalCacheImpl( private val targetDataRoot: File, - targetOutputDir: File?, - target: Target + targetOutputDir: File? ) : IncrementalCacheCommon(File(targetDataRoot, KOTLIN_CACHE_DIRECTORY_NAME)), IncrementalCache { companion object { private val PROTO_MAP = "proto" @@ -77,7 +76,7 @@ open class IncrementalCacheImpl( // todo: try to use internal names only? private val internalNameToSource = registerMap(InternalNameToSourcesMap(INTERNAL_NAME_TO_SOURCE.storageFile)) - private val outputDir by lazy(LazyThreadSafetyMode.NONE) { requireNotNull(targetOutputDir) { "Target is expected to have output directory: $target" } } + private val outputDir by lazy(LazyThreadSafetyMode.NONE) { requireNotNull(targetOutputDir) { "Target is expected to have output directory" } } protected open fun debugLog(message: String) {} @@ -115,7 +114,7 @@ open class IncrementalCacheImpl( return CompilationResult.NO_CHANGES } - open fun saveFileToCache(generatedClass: GeneratedJvmClass): CompilationResult { + open fun saveFileToCache(generatedClass: GeneratedJvmClass<*>): CompilationResult { val sourceFiles: Collection = generatedClass.sourceFiles val kotlinClass: LocalFileKotlinClass = generatedClass.outputClass val className = kotlinClass.className diff --git a/build-common/src/org/jetbrains/kotlin/incremental/buildUtil.kt b/build-common/src/org/jetbrains/kotlin/incremental/buildUtil.kt index cface9d482d..fba1a17e0a7 100644 --- a/build-common/src/org/jetbrains/kotlin/incremental/buildUtil.kt +++ b/build-common/src/org/jetbrains/kotlin/incremental/buildUtil.kt @@ -14,9 +14,6 @@ * limitations under the License. */ -// these functions are used in the kotlin gradle plugin -@file:Suppress("unused") - package org.jetbrains.kotlin.incremental import com.intellij.openapi.util.io.FileUtil @@ -25,8 +22,6 @@ import org.jetbrains.kotlin.build.GeneratedFile import org.jetbrains.kotlin.build.GeneratedJvmClass import org.jetbrains.kotlin.build.JvmSourceRoot import org.jetbrains.kotlin.build.isModuleMappingFile -import org.jetbrains.kotlin.compilerRunner.OutputItemsCollectorImpl -import org.jetbrains.kotlin.config.IncrementalCompilation import org.jetbrains.kotlin.config.Services import org.jetbrains.kotlin.incremental.components.LookupTracker import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCache @@ -35,14 +30,9 @@ import org.jetbrains.kotlin.modules.KotlinModuleXmlBuilder import org.jetbrains.kotlin.modules.TargetId import org.jetbrains.kotlin.name.FqName import org.jetbrains.kotlin.progress.CompilationCanceledStatus -import org.jetbrains.kotlin.utils.keysToMap import java.io.File import java.util.* - -fun Iterable.javaSourceRoots(roots: Iterable): Iterable = - filter(File::isJavaFile).mapNotNull { findSrcDirRoot(it, roots) } - fun makeModuleFile( name: String, isTest: Boolean, @@ -86,61 +76,22 @@ fun makeCompileServices( build() } -fun makeLookupTracker(parentLookupTracker: LookupTracker = LookupTracker.DO_NOTHING): LookupTracker = - if (IncrementalCompilation.isEnabled()) LookupTrackerImpl(parentLookupTracker) - else parentLookupTracker - -fun makeIncrementalCachesMap( - targets: Iterable, - getDependencies: (Target) -> Iterable, - getCache: (Target) -> IncrementalCacheImpl, - getTargetId: Target.() -> TargetId -): Map> -{ - val dependents = targets.keysToMap { hashSetOf() } - val targetsWithDependents = targets.toHashSet() - - for (target in targets) { - for (dependency in getDependencies(target)) { - if (dependency !in targets) continue - - dependents[dependency]!!.add(target) - targetsWithDependents.add(target) - } - } - - val caches = targetsWithDependents.keysToMap { getCache(it) } - - for ((target, cache) in caches) { - dependents[target]?.forEach { - cache.addDependentCache(caches[it]!!) - } - } - - return caches.mapKeys { it.key.getTargetId() } -} - -fun updateIncrementalCaches( - targets: Iterable, - generatedFiles: List>, - compiledWithErrors: Boolean, - getIncrementalCache: (Target) -> IncrementalCacheImpl +fun updateIncrementalCache( + generatedFiles: List>, + cache: IncrementalCacheImpl, + compiledWithErrors: Boolean ): CompilationResult { - var changesInfo = CompilationResult.NO_CHANGES for (generatedFile in generatedFiles) { - val ic = getIncrementalCache(generatedFile.target) when { - generatedFile is GeneratedJvmClass -> changesInfo += ic.saveFileToCache(generatedFile) - generatedFile.outputFile.isModuleMappingFile() -> changesInfo += ic.saveModuleMappingToCache(generatedFile.sourceFiles, generatedFile.outputFile) + generatedFile is GeneratedJvmClass<*> -> changesInfo += cache.saveFileToCache(generatedFile) + generatedFile.outputFile.isModuleMappingFile() -> changesInfo += cache.saveModuleMappingToCache(generatedFile.sourceFiles, generatedFile.outputFile) } } if (!compiledWithErrors) { - targets.forEach { - val newChangesInfo = getIncrementalCache(it).clearCacheForRemovedClasses() - changesInfo += newChangesInfo - } + val newChangesInfo = cache.clearCacheForRemovedClasses() + changesInfo += newChangesInfo } return changesInfo @@ -158,30 +109,6 @@ fun LookupStorage.update( addAll(lookupTracker.lookups.entrySet(), lookupTracker.pathInterner.values) } -fun OutputItemsCollectorImpl.generatedFiles( - targets: Collection, - representativeTarget: Target, - getSources: (Target) -> Iterable, - getOutputDir: (Target) -> File? -): List> { - // If there's only one target, this map is empty: get() always returns null, and the representativeTarget will be used below - val sourceToTarget = - if (targets.size >1) targets.flatMap { target -> getSources(target).map { Pair(it, target) } }.toMap() - else mapOf() - - return outputs.map { outputItem -> - val target = - outputItem.sourceFiles.firstOrNull()?.let { sourceToTarget[it] } ?: - targets.singleOrNull { getOutputDir(it)?.let { outputItem.outputFile.startsWith(it) } ?: false } ?: - representativeTarget - - when (outputItem.outputFile.extension) { - "class" -> GeneratedJvmClass(target, outputItem.sourceFiles, outputItem.outputFile) - else -> GeneratedFile(target, outputItem.sourceFiles, outputItem.outputFile) - } - } -} - data class DirtyData( val dirtyLookupSymbols: Collection = emptyList(), val dirtyClassesFqNames: Collection = emptyList() @@ -262,9 +189,6 @@ fun mapClassesFqNamesToFiles( return dirtyFiles } -private fun findSrcDirRoot(file: File, roots: Iterable): File? = - roots.firstOrNull { FileUtil.isAncestor(it, file, false) } - fun withSubtypes( typeFqName: FqName, caches: Iterable 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 9124155d845..3971e3ebd9b 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,7 +17,6 @@ package org.jetbrains.kotlin.incremental import org.jetbrains.kotlin.incremental.storage.BasicMapsOwner -import org.jetbrains.kotlin.modules.TargetId import java.io.File abstract class IncrementalCachesManager ( @@ -68,12 +67,11 @@ abstract class IncrementalCachesManager ( } class IncrementalJvmCachesManager( - targetId: TargetId, cacheDirectory: File, outputDir: File, reporter: ICReporter ) : IncrementalCachesManager(cacheDirectory, reporter) { private val jvmCacheFile = File(cacheDirectory, "jvm").apply { mkdirs() } - val jvmCache = IncrementalCacheImpl(jvmCacheFile, outputDir, targetId).apply { registerCache() } + val jvmCache = IncrementalCacheImpl(jvmCacheFile, outputDir).apply { registerCache() } } \ No newline at end of file diff --git a/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalJvmCompilerRunner.kt b/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalJvmCompilerRunner.kt index 169d764b311..e830406ebf5 100644 --- a/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalJvmCompilerRunner.kt +++ b/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalJvmCompilerRunner.kt @@ -104,8 +104,7 @@ class IncrementalJvmCompilerRunner( messageCollector: MessageCollector, getChangedFiles: (IncrementalCachesManager)->ChangedFiles ): ExitCode { - val targetId = TargetId(name = args.moduleName!!, type = "java-production") - var caches = IncrementalJvmCachesManager(targetId, cacheDirectory, File(args.destination), reporter) + var caches = IncrementalJvmCachesManager(cacheDirectory, File(args.destination), reporter) fun rebuild(): ExitCode { caches.clean() @@ -113,8 +112,8 @@ class IncrementalJvmCompilerRunner( args.destinationAsFile.deleteRecursively() val javaFilesProcessor = ChangedJavaFilesProcessor(reporter) - caches = IncrementalJvmCachesManager(targetId, cacheDirectory, args.destinationAsFile, reporter) - return compileIncrementally(args, caches, javaFilesProcessor, allKotlinSources, targetId, CompilationMode.Rebuild, messageCollector) + caches = IncrementalJvmCachesManager(cacheDirectory, args.destinationAsFile, reporter) + return compileIncrementally(args, caches, javaFilesProcessor, allKotlinSources, CompilationMode.Rebuild, messageCollector) } return try { @@ -124,7 +123,7 @@ class IncrementalJvmCompilerRunner( val exitCode = when (compilationMode) { is CompilationMode.Incremental -> { - compileIncrementally(args, caches, javaFilesProcessor, allKotlinSources, targetId, compilationMode, messageCollector) + compileIncrementally(args, caches, javaFilesProcessor, allKotlinSources, compilationMode, messageCollector) } is CompilationMode.Rebuild -> { rebuild() @@ -254,7 +253,6 @@ class IncrementalJvmCompilerRunner( caches: IncrementalJvmCachesManager, javaFilesProcessor: ChangedJavaFilesProcessor, allKotlinSources: List, - targetId: TargetId, compilationMode: CompilationMode, messageCollector: MessageCollector ): ExitCode { @@ -296,7 +294,7 @@ class IncrementalJvmCompilerRunner( val text = allSourcesToCompile.joinToString(separator = System.getProperty("line.separator")) { it.canonicalPath } dirtySourcesSinceLastTimeFile.writeText(text) - val compilerOutput = compileChanged(listOf(targetId), sourcesToCompile.toSet(), args, caches.jvmCache, lookupTracker, messageCollector) + val compilerOutput = compileChanged(sourcesToCompile.toSet(), args, caches.jvmCache, lookupTracker, messageCollector) exitCode = compilerOutput.exitCode val generatedFiles = compilerOutput.generatedFiles anyClassesCompiled = anyClassesCompiled || generatedFiles.isNotEmpty() || removedKotlinSources.isNotEmpty() @@ -320,9 +318,7 @@ class IncrementalJvmCompilerRunner( allGeneratedFiles.addAll(generatedFiles) caches.inputsCache.registerOutputForSourceFiles(generatedFiles) - val compilationResult = updateIncrementalCaches(listOf(targetId), generatedFiles, - compiledWithErrors = exitCode != ExitCode.OK, - getIncrementalCache = { caches.jvmCache }) + val compilationResult = updateIncrementalCache(generatedFiles, caches.jvmCache, compiledWithErrors = exitCode != ExitCode.OK) caches.lookupCache.update(lookupTracker, sourcesToCompile, removedKotlinSources) @@ -365,7 +361,7 @@ class IncrementalJvmCompilerRunner( } private fun additionalDirtyFiles( - cache: IncrementalCacheImpl, + cache: IncrementalCacheImpl, generatedFiles: List> ): Collection { val result = HashSet() @@ -403,10 +399,9 @@ class IncrementalJvmCompilerRunner( } private fun compileChanged( - targets: List, sourcesToCompile: Set, args: K2JVMCompilerArguments, - cache: IncrementalCacheImpl, + cache: IncrementalCacheImpl, lookupTracker: LookupTracker, messageCollector: MessageCollector ): CompileChangedResults { @@ -429,7 +424,8 @@ class IncrementalJvmCompilerRunner( val messageCollector = MessageCollectorWrapper(messageCollector, outputItemCollector) try { - val incrementalCaches = makeIncrementalCachesMap(targets, { listOf() }, { cache }, { this }) + val targetId = TargetId(args.moduleName, "java-production") + val incrementalCaches = mapOf(targetId to cache) val compilationCanceledStatus = object : CompilationCanceledStatus { override fun checkCanceled() { } @@ -439,7 +435,14 @@ class IncrementalJvmCompilerRunner( reporter.report { "compiling with classpath: ${classpath.toList().sorted().joinToString()}" } val compileServices = makeCompileServices(incrementalCaches, lookupTracker, compilationCanceledStatus) val exitCode = compiler.exec(messageCollector, compileServices, args) - val generatedFiles = outputItemCollector.generatedFiles(targets, targets.first(), {sourcesToCompile}, {outputDir}) + val generatedFiles = outputItemCollector.outputs.map { + val outputItem = it.outputFile + val sourceFiles = it.sourceFiles + when (outputItem.extension) { + "class" -> GeneratedJvmClass(targetId, sourceFiles, outputItem) + else -> GeneratedFile(targetId, sourceFiles, outputItem) + } + } reporter.reportCompileIteration(sourcesToCompile, exitCode) return CompileChangedResults(exitCode, generatedFiles) } 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 b41645a9e69..a0d9523dc55 100644 --- a/jps-plugin/src/org/jetbrains/kotlin/jps/build/KotlinBuilder.kt +++ b/jps-plugin/src/org/jetbrains/kotlin/jps/build/KotlinBuilder.kt @@ -424,7 +424,7 @@ class KotlinBuilder : ModuleLevelBuilder(BuilderCategory.SOURCE_PROCESSOR) { private fun doCompileModuleChunk( allCompiledFiles: MutableSet, chunk: ModuleChunk, commonArguments: CommonCompilerArguments, context: CompileContext, dirtyFilesHolder: DirtyFilesHolder, environment: JpsCompilerEnvironment, - filesToCompile: MultiMap, incrementalCaches: Map>, + filesToCompile: MultiMap, incrementalCaches: Map, project: JpsProject ): OutputItemsCollector? { @@ -827,7 +827,7 @@ private fun CompilationResult.processChangesUsingLookups( compiledFiles: Set, dataManager: BuildDataManager, fsOperations: FSOperationsHelper, - caches: Iterable> + caches: Iterable ) { val lookupStorage = dataManager.getStorage(KotlinDataContainerTarget, JpsLookupStorageProvider) val allCaches = caches.flatMap { it.thisWithDependentCaches } 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 ca7990987f7..4bc52d42ff0 100644 --- a/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/JpsIncrementalCacheImpl.kt +++ b/jps-plugin/src/org/jetbrains/kotlin/jps/incremental/JpsIncrementalCacheImpl.kt @@ -28,7 +28,7 @@ import java.io.File class JpsIncrementalCacheImpl( target: ModuleBuildTarget, paths: BuildDataPaths -) : IncrementalCacheImpl(paths.getTargetDataRoot(target), target.outputDir, target), StorageOwner { +) : IncrementalCacheImpl(paths.getTargetDataRoot(target), target.outputDir), StorageOwner { override fun debugLog(message: String) { KotlinBuilder.LOG.debug(message) }