Implement module detection for Gradle IC with Android

#KT-22431 fixed

compiler/daemon/daemon-common/src/org/jetbrains/kotlin/daemon/common/CompilationOptions.kt

@@ -65,7 +65,7 @@ class IncrementalCompilationOptions(
          * Directories that should be cleared when IC decides to rebuild
          */
         val localStateDirs: List<File>,
-        val buildHistoryFile: File,
+        val multiModuleICSettings: MultiModuleICSettings,
         val modulesInfo: IncrementalModuleInfo
 ) : CompilationOptions(compilerMode, targetPlatform, reportCategories, reportSeverity, requestedCompilationResults) {
     companion object {
@@ -81,13 +81,22 @@ class IncrementalCompilationOptions(
                "workingDir=$workingDir, " +
                "customCacheVersionFileName='$customCacheVersionFileName', " +
                "customCacheVersion=$customCacheVersion, " +
-               "buildHistoryFile=$buildHistoryFile, " +
+               "multiModuleICSettings=$multiModuleICSettings, " +
                "usePreciseJavaTracking=$usePreciseJavaTracking" +
                "localStateDirs=$localStateDirs" +
                ")"
     }
 }
 
+data class MultiModuleICSettings(
+    val buildHistoryFile: File,
+    val useModuleDetection: Boolean
+) : Serializable {
+    companion object {
+        const val serialVersionUID: Long = 0
+    }
+}
+
 enum class CompilerMode : Serializable {
     NON_INCREMENTAL_COMPILER,
     INCREMENTAL_COMPILER,

compiler/daemon/src/org/jetbrains/kotlin/daemon/CompileServiceImpl.kt

@@ -48,6 +48,7 @@ import org.jetbrains.kotlin.daemon.report.RemoteICReporter
 import org.jetbrains.kotlin.incremental.*
 import org.jetbrains.kotlin.incremental.components.LookupTracker
 import org.jetbrains.kotlin.incremental.parsing.classesFqNames
+import org.jetbrains.kotlin.incremental.multiproject.ModulesApiHistoryAndroid
 import org.jetbrains.kotlin.incremental.multiproject.ModulesApiHistoryJvm
 import org.jetbrains.kotlin.load.kotlin.incremental.components.IncrementalCompilationComponents
 import org.jetbrains.kotlin.modules.Module
@@ -523,14 +524,20 @@ class CompileServiceImpl(
                                           workingDir,
                                           enabled = true)
 
-        val modulesApiHistory = ModulesApiHistoryJvm(incrementalCompilationOptions.modulesInfo)
+        val modulesApiHistory = incrementalCompilationOptions.run {
+            if (!multiModuleICSettings.useModuleDetection) {
+                ModulesApiHistoryJvm(modulesInfo)
+            } else {
+                ModulesApiHistoryAndroid(modulesInfo)
+            }
+        }
 
         val compiler = IncrementalJvmCompilerRunner(
             workingDir,
             javaSourceRoots,
             versions,
             reporter, annotationFileUpdater,
-            buildHistoryFile = incrementalCompilationOptions.buildHistoryFile,
+            buildHistoryFile = incrementalCompilationOptions.multiModuleICSettings.buildHistoryFile,
             localStateDirs = incrementalCompilationOptions.localStateDirs,
             usePreciseJavaTracking = incrementalCompilationOptions.usePreciseJavaTracking,
             modulesApiHistory = modulesApiHistory

compiler/incremental-compilation-impl/src/org/jetbrains/kotlin/incremental/multiproject/ModulesApiHistory.kt

@@ -97,5 +97,43 @@ open class ModulesApiHistoryJvm(protected val modulesInfo: IncrementalModuleInfo
     }
 }
 
+class ModulesApiHistoryAndroid(modulesInfo: IncrementalModuleInfo) : ModulesApiHistoryJvm(modulesInfo) {
+    override fun getBuildHistoryFilesForJar(jar: File): Either<Set<File>> {
+        // Module detection is expensive, so we don't don it for jars outside of project dir
+        if (!projectRootPath.isParentOf(jar)) return Either.Error("Non-project jar is modified $jar")
+
+        val jarPath = Paths.get(jar.absolutePath)
+        val possibleModules = getPossibleModuleNamesFromJar(jarPath)
+            .flatMapTo(HashSet()) { modulesInfo.nameToModules[it] ?: emptySet() }
+
+        val modules = possibleModules.filter { Paths.get(it.buildDir.absolutePath).isParentOf(jarPath) }
+        if (modules.isEmpty()) return Either.Error("Unknown module for $jar (candidates: ${possibleModules.joinToString()})")
+
+        val result = modules.mapTo(HashSet()) { it.buildHistoryFile }
+        return Either.Success(result)
+    }
+
+    private fun getPossibleModuleNamesFromJar(path: Path): Collection<String> {
+        val result = HashSet<String>()
+
+        try {
+            ZipFile(path.toFile()).use { zip ->
+                val entries = zip.entries()
+                while (entries.hasMoreElements()) {
+                    val entry = entries.nextElement()
+                    val name = entry.name
+                    if (name.endsWith(".kotlin_module", ignoreCase = true)) {
+                        result.add(File(name).nameWithoutExtension)
+                    }
+                }
+            }
+        } catch (t: Throwable) {
+            return emptyList()
+        }
+
+        return result
+    }
+}
+
 private fun Path.isParentOf(path: Path) = path.startsWith(this)
 private fun Path.isParentOf(file: File) = this.isParentOf(Paths.get(file.absolutePath))