From aeaf1d66333dc82f191d7dfeeaa650d5770a7624 Mon Sep 17 00:00:00 2001 From: Alexey Tsvetkov Date: Tue, 3 Jul 2018 14:56:18 +0300 Subject: [PATCH] Refactoring: introduce DirtyFilesContainer for better code reuse in IC --- .../kotlin/incremental/DirtyFilesContainer.kt | 47 +++++++++++++++++++ .../incremental/IncrementalCompilerRunner.kt | 16 +++---- .../IncrementalJsCompilerRunner.kt | 24 ++-------- .../IncrementalJvmCompilerRunner.kt | 33 ++++--------- 4 files changed, 66 insertions(+), 54 deletions(-) create mode 100644 compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/DirtyFilesContainer.kt diff --git a/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/DirtyFilesContainer.kt b/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/DirtyFilesContainer.kt new file mode 100644 index 00000000000..2be16541638 --- /dev/null +++ b/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/DirtyFilesContainer.kt @@ -0,0 +1,47 @@ +/* + * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license + * that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.incremental + +import org.jetbrains.kotlin.name.FqName +import java.io.File + +class DirtyFilesContainer( + private val caches: IncrementalCachesManager<*>, + private val reporter: ICReporter +) { + private val myDirtyFiles = HashSet() + + fun toMutableList(): MutableList = + ArrayList(myDirtyFiles) + + fun add(files: Iterable) { + val existingKotlinFiles = files.filter { it.isKotlinFile() } + if (existingKotlinFiles.isNotEmpty()) { + myDirtyFiles.addAll(existingKotlinFiles) + } + } + + fun addByDirtySymbols(lookupSymbols: Collection) { + if (lookupSymbols.isEmpty()) return + + val dirtyFilesFromLookups = mapLookupSymbolsToFiles(caches.lookupCache, lookupSymbols, reporter) + add(dirtyFilesFromLookups) + } + + fun addByDirtyClasses(dirtyClassesFqNames: Collection) { + if (dirtyClassesFqNames.isEmpty()) return + + val fqNamesWithSubtypes = dirtyClassesFqNames.flatMap { + withSubtypes( + it, + listOf(caches.platformCache) + ) + } + val dirtyFilesFromFqNames = + mapClassesFqNamesToFiles(listOf(caches.platformCache), fqNamesWithSubtypes, reporter) + add(dirtyFilesFromFqNames) + } +} \ No newline at end of file diff --git a/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalCompilerRunner.kt b/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalCompilerRunner.kt index 1588fcafbe0..e5856ae97b6 100644 --- a/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalCompilerRunner.kt +++ b/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalCompilerRunner.kt @@ -117,11 +117,9 @@ abstract class IncrementalCompilerRunner< protected abstract fun calculateSourcesToCompile(caches: CacheManager, changedFiles: ChangedFiles.Known, args: Args): CompilationMode - protected fun getDirtyFiles(changedFiles: ChangedFiles.Known): HashSet { - val dirtyFiles = HashSet(with(changedFiles) { modified.size + removed.size }) - with(changedFiles) { - modified.asSequence() + removed.asSequence() - }.filterTo(dirtyFiles, File::isKotlinFile) + protected fun initDirtyFiles(dirtyFiles: DirtyFilesContainer, changedFiles: ChangedFiles.Known) { + dirtyFiles.add(changedFiles.modified) + dirtyFiles.add(changedFiles.removed) if (dirtySourcesSinceLastTimeFile.exists()) { val files = dirtySourcesSinceLastTimeFile.readLines().map(::File) @@ -129,14 +127,12 @@ abstract class IncrementalCompilerRunner< reporter.report { "Source files added since last compilation: ${reporter.pathsAsString(files)}" } } - dirtyFiles.addAll(files) + dirtyFiles.add(files) } - - return dirtyFiles } protected sealed class CompilationMode { - class Incremental(val dirtyFiles: Set) : CompilationMode() + class Incremental(val dirtyFiles: DirtyFilesContainer) : CompilationMode() class Rebuild(getReason: () -> String = { "" }) : CompilationMode() { val reason: String by lazy(getReason) } @@ -188,7 +184,7 @@ abstract class IncrementalCompilerRunner< preBuildHook(args, compilationMode) val dirtySources = when (compilationMode) { - is CompilationMode.Incremental -> ArrayList(compilationMode.dirtyFiles) + is CompilationMode.Incremental -> compilationMode.dirtyFiles.toMutableList() is CompilationMode.Rebuild -> allKotlinSources.toMutableList() } diff --git a/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalJsCompilerRunner.kt b/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalJsCompilerRunner.kt index bff39339687..fa739833b98 100644 --- a/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalJsCompilerRunner.kt +++ b/compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/IncrementalJsCompilerRunner.kt @@ -27,7 +27,6 @@ import org.jetbrains.kotlin.config.Services import org.jetbrains.kotlin.incremental.components.ExpectActualTracker import org.jetbrains.kotlin.incremental.components.LookupTracker import org.jetbrains.kotlin.incremental.js.* -import org.jetbrains.kotlin.name.FqName import java.io.File fun makeJsIncrementally( @@ -91,27 +90,12 @@ class IncrementalJsCompilerRunner( if (changedLib != null) return CompilationMode.Rebuild { "Library has been changed: $changedLib" } - val dirtyFiles = getDirtyFiles(changedFiles) - - // todo: unify with JVM calculateSourcesToCompile - fun markDirtyBy(lookupSymbols: Collection) { - if (lookupSymbols.isEmpty()) return - - val dirtyFilesFromLookups = mapLookupSymbolsToFiles(caches.lookupCache, lookupSymbols, reporter) - dirtyFiles.addAll(dirtyFilesFromLookups) - } - - fun markDirtyBy(dirtyClassesFqNames: Collection) { - if (dirtyClassesFqNames.isEmpty()) return - - val fqNamesWithSubtypes = dirtyClassesFqNames.flatMap { withSubtypes(it, listOf(caches.platformCache)) } - val dirtyFilesFromFqNames = mapClassesFqNamesToFiles(listOf(caches.platformCache), fqNamesWithSubtypes, reporter) - dirtyFiles.addAll(dirtyFilesFromFqNames) - } + val dirtyFiles = DirtyFilesContainer(caches, reporter) + initDirtyFiles(dirtyFiles, changedFiles) val removedClassesChanges = getRemovedClassesChanges(caches, changedFiles) - markDirtyBy(removedClassesChanges.dirtyLookupSymbols) - markDirtyBy(removedClassesChanges.dirtyClassesFqNames) + dirtyFiles.addByDirtySymbols(removedClassesChanges.dirtyLookupSymbols) + dirtyFiles.addByDirtyClasses(removedClassesChanges.dirtyClassesFqNames) return CompilationMode.Incremental(dirtyFiles) } 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 ef84622d137..7ed87681eb6 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 @@ -144,22 +144,8 @@ class IncrementalJvmCompilerRunner( changedFiles: ChangedFiles.Known, args: K2JVMCompilerArguments ): CompilationMode { - val dirtyFiles = getDirtyFiles(changedFiles) - - fun markDirtyBy(lookupSymbols: Collection) { - if (lookupSymbols.isEmpty()) return - - val dirtyFilesFromLookups = mapLookupSymbolsToFiles(caches.lookupCache, lookupSymbols, reporter) - dirtyFiles.addAll(dirtyFilesFromLookups) - } - - fun markDirtyBy(dirtyClassesFqNames: Collection) { - if (dirtyClassesFqNames.isEmpty()) return - - val fqNamesWithSubtypes = dirtyClassesFqNames.flatMap { withSubtypes(it, listOf(caches.platformCache)) } - val dirtyFilesFromFqNames = mapClassesFqNamesToFiles(listOf(caches.platformCache), fqNamesWithSubtypes, reporter) - dirtyFiles.addAll(dirtyFilesFromFqNames) - } + val dirtyFiles = DirtyFilesContainer(caches, reporter) + initDirtyFiles(dirtyFiles, changedFiles) val lastBuildInfo = BuildInfo.read(lastBuildInfoFile) ?: return CompilationMode.Rebuild { "No information on previous build" } reporter.report { "Last Kotlin Build info -- $lastBuildInfo" } @@ -173,8 +159,8 @@ class IncrementalJvmCompilerRunner( "Could not get classpath's changes${classpathChanges.reason?.let { ": $it" }}" } is ChangesEither.Known -> { - markDirtyBy(classpathChanges.lookupSymbols) - markDirtyBy(classpathChanges.fqNames) + dirtyFiles.addByDirtySymbols(classpathChanges.lookupSymbols) + dirtyFiles.addByDirtyClasses(classpathChanges.fqNames) } } @@ -184,9 +170,8 @@ class IncrementalJvmCompilerRunner( is ChangesEither.Known -> javaFilesChanges.lookupSymbols is ChangesEither.Unknown -> return CompilationMode.Rebuild { "Could not get changes for java files" } } - markDirtyBy(affectedJavaSymbols) - } - else { + dirtyFiles.addByDirtySymbols(affectedJavaSymbols) + } else { if (!processChangedJava(changedFiles, caches)) { return CompilationMode.Rebuild { "Could not get changes for java files" } } @@ -195,9 +180,9 @@ class IncrementalJvmCompilerRunner( val androidLayoutChanges = processLookupSymbolsForAndroidLayouts(changedFiles) val removedClassesChanges = getRemovedClassesChanges(caches, changedFiles) - markDirtyBy(androidLayoutChanges) - markDirtyBy(removedClassesChanges.dirtyLookupSymbols) - markDirtyBy(removedClassesChanges.dirtyClassesFqNames) + dirtyFiles.addByDirtySymbols(androidLayoutChanges) + dirtyFiles.addByDirtySymbols(removedClassesChanges.dirtyLookupSymbols) + dirtyFiles.addByDirtyClasses(removedClassesChanges.dirtyClassesFqNames) return CompilationMode.Incremental(dirtyFiles) }