Add property for precise version of Java tracking in Gradle IC

The flag name is kotlin.incremental.usePreciseJavaTracking By default precise version is disabled #KT-17621 Fixed
2017-12-04 15:05:58 +03:00
parent a978c6be35
commit a079b92ea0
12 changed files with 231 additions and 63 deletions
@@ -0,0 +1,67 @@
+/*
+ * Copyright 2010-2016 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.incremental
+
+import com.intellij.psi.PsiClass
+import com.intellij.psi.PsiFile
+import com.intellij.psi.PsiJavaFile
+import java.io.File
+import java.util.*
+
+internal class ChangedJavaFilesProcessor(
+        private val reporter: ICReporter,
+        private val psiFileFactory: (File) -> PsiFile?
+) {
+    private val allSymbols = HashSet<LookupSymbol>()
+
+    val allChangedSymbols: Collection<LookupSymbol>
+        get() = allSymbols
+
+    fun process(filesDiff: ChangedFiles.Known): ChangesEither {
+        val modifiedJava = filesDiff.modified.filter(File::isJavaFile)
+        val removedJava = filesDiff.removed.filter(File::isJavaFile)
+
+        if (removedJava.any()) {
+            reporter.report { "Some java files are removed: [${removedJava.joinToString()}]" }
+            return ChangesEither.Unknown()
+        }
+
+        val symbols = HashSet<LookupSymbol>()
+        for (javaFile in modifiedJava) {
+            assert(javaFile.extension.equals("java", ignoreCase = true))
+
+            val psiFile = psiFileFactory(javaFile)
+            if (psiFile !is PsiJavaFile) {
+                reporter.report { "Expected PsiJavaFile, got ${psiFile?.javaClass}" }
+                return ChangesEither.Unknown()
+            }
+
+            psiFile.classes.forEach { it.addLookupSymbols(symbols) }
+        }
+        allSymbols.addAll(symbols)
+        return ChangesEither.Known(lookupSymbols = symbols)
+    }
+
+    private fun PsiClass.addLookupSymbols(symbols: MutableSet<LookupSymbol>) {
+        val fqn = qualifiedName.orEmpty()
+
+        symbols.add(LookupSymbol(name.orEmpty(), if (fqn == name) "" else fqn.removeSuffix("." + name!!)))
+        methods.forEach { symbols.add(LookupSymbol(it.name, fqn)) }
+        fields.forEach { symbols.add(LookupSymbol(it.name.orEmpty(), fqn)) }
+        innerClasses.forEach { it.addLookupSymbols(symbols) }
+    }
+}
@@ -143,6 +143,9 @@ abstract class IncrementalCompilerRunner<
    protected open fun additionalDirtyFiles(caches: CacheManager, generatedFiles: List<GeneratedFile>): Iterable<File> =
            emptyList()

+    protected open fun additionalDirtyLookupSymbols(): Iterable<LookupSymbol> =
+            emptyList()
+
    protected open fun makeServices(
            args: Args,
            lookupTracker: LookupTracker,
@@ -245,6 +248,9 @@ abstract class IncrementalCompilerRunner<
        if (exitCode == ExitCode.OK) {
            BuildInfo.write(currentBuildInfo, lastBuildInfoFile)
        }
+        if (exitCode == ExitCode.OK && compilationMode is CompilationMode.Incremental) {
+            buildDirtyLookupSymbols.addAll(additionalDirtyLookupSymbols())
+        }

        val dirtyData = DirtyData(buildDirtyLookupSymbols, buildDirtyFqNames)
        processChangesAfterBuild(compilationMode, currentBuildInfo, dirtyData)
@@ -66,9 +66,13 @@ fun makeIncrementally(
    val kotlinFiles = sourceFiles.filter { it.extension.toLowerCase() in kotlinExtensions }

    withIC {
-        val compiler = IncrementalJvmCompilerRunner(cachesDir,
-                                                    sourceRoots.map { JvmSourceRoot(it, null) }.toSet(),
-                                                    versions, reporter)
+        val compiler = IncrementalJvmCompilerRunner(
+                cachesDir,
+                sourceRoots.map { JvmSourceRoot(it, null) }.toSet(),
+                versions, reporter,
+                // Use precise setting in case of non-Gradle build
+                usePreciseJavaTracking = true
+        )
        compiler.compile(kotlinFiles, args, messageCollector) {
            it.inputsCache.sourceSnapshotMap.compareAndUpdate(sourceFiles)
        }
@@ -101,7 +105,8 @@ class IncrementalJvmCompilerRunner(
        artifactChangesProvider: ArtifactChangesProvider? = null,
        changesRegistry: ChangesRegistry? = null,
        private val buildHistoryFile: File? = null,
-        private val friendBuildHistoryFile: File? = null
+        private val friendBuildHistoryFile: File? = null,
+        private val usePreciseJavaTracking: Boolean
 ) : IncrementalCompilerRunner<K2JVMCompilerArguments, IncrementalJvmCachesManager>(
        workingDir,
        "caches-jvm",
@@ -129,6 +134,12 @@ class IncrementalJvmCompilerRunner(

    private val changedUntrackedJavaClasses = mutableSetOf<ClassId>()

+    private var javaFilesProcessor =
+            if (!usePreciseJavaTracking)
+                ChangedJavaFilesProcessor(reporter) { it.psiFile() }
+            else
+                null
+
    override fun calculateSourcesToCompile(caches: IncrementalJvmCachesManager, changedFiles: ChangedFiles.Known, args: K2JVMCompilerArguments): CompilationMode {
        val dirtyFiles = getDirtyFiles(changedFiles)

@@ -187,8 +198,18 @@ class IncrementalJvmCompilerRunner(
            return CompilationMode.Rebuild { "could not get changes from modified classpath entries: ${reporter.pathsAsString(modifiedClasspathEntries)}" }
        }

-        if (!processChangedJava(changedFiles, caches)) {
-            return CompilationMode.Rebuild { "Could not get changes for java files" }
+        if (!usePreciseJavaTracking) {
+            val javaFilesChanges = javaFilesProcessor!!.process(changedFiles)
+            val affectedJavaSymbols = when (javaFilesChanges) {
+                is ChangesEither.Known -> javaFilesChanges.lookupSymbols
+                is ChangesEither.Unknown -> return CompilationMode.Rebuild { "Could not get changes for java files" }
+            }
+            markDirtyBy(affectedJavaSymbols)
+        }
+        else {
+            if (!processChangedJava(changedFiles, caches)) {
+                return CompilationMode.Rebuild { "Could not get changes for java files" }
+            }
        }

        if ((changedFiles.modified + changedFiles.removed).any { it.extension.toLowerCase() == "xml" }) {
@@ -350,6 +371,9 @@ class IncrementalJvmCompilerRunner(
        return result
    }

+    override fun additionalDirtyLookupSymbols(): Iterable<LookupSymbol> =
+            javaFilesProcessor?.allChangedSymbols ?: emptyList()
+
    override fun processChangesAfterBuild(compilationMode: CompilationMode, currentBuildInfo: BuildInfo, dirtyData: DirtyData) {
        super.processChangesAfterBuild(compilationMode, currentBuildInfo, dirtyData)

@@ -378,9 +402,11 @@ class IncrementalJvmCompilerRunner(
            val targetToCache = mapOf(targetId to caches.platformCache)
            val incrementalComponents = IncrementalCompilationComponentsImpl(targetToCache)
            register(IncrementalCompilationComponents::class.java, incrementalComponents)
-            val changesTracker = JavaClassesTrackerImpl(caches.platformCache, changedUntrackedJavaClasses.toSet())
-            changedUntrackedJavaClasses.clear()
-            register(JavaClassesTracker::class.java, changesTracker)
+            if (usePreciseJavaTracking) {
+                val changesTracker = JavaClassesTrackerImpl(caches.platformCache, changedUntrackedJavaClasses.toSet())
+                changedUntrackedJavaClasses.clear()
+                register(JavaClassesTracker::class.java, changesTracker)
+            }
        }

    override fun runCompiler(