[Gradle] Remove KotlinCompileTaskData

When getting the incremental compilation information use the
task graph which processes all tasks present in it. Tasks have
all information that is needed to get IncrementalModuleInfo for all
compilations.
This commit is contained in:
Ivan Gavrilovic
2021-04-26 16:53:00 +01:00
committed by teamcityserver
parent b3d8187df4
commit 56cad96718
2 changed files with 41 additions and 113 deletions
@@ -4,9 +4,7 @@
*/
package org.jetbrains.kotlin.compilerRunner
import org.gradle.api.Project
import org.gradle.api.UnknownTaskException
import org.gradle.api.invocation.Gradle
import org.gradle.api.logging.Logger
import org.gradle.api.plugins.JavaPluginConvention
@@ -16,18 +14,16 @@ import org.jetbrains.kotlin.cli.common.arguments.*
import org.jetbrains.kotlin.cli.common.messages.MessageCollector
import org.jetbrains.kotlin.daemon.client.CompileServiceSession
import org.jetbrains.kotlin.daemon.common.CompilerId
import org.jetbrains.kotlin.gradle.dsl.kotlinExtensionOrNull
import org.jetbrains.kotlin.gradle.dsl.KotlinMultiplatformExtension
import org.jetbrains.kotlin.gradle.dsl.multiplatformExtensionOrNull
import org.jetbrains.kotlin.gradle.logging.kotlinDebug
import org.jetbrains.kotlin.gradle.plugin.KotlinCompilation
import org.jetbrains.kotlin.gradle.plugin.KotlinPlatformType
import org.jetbrains.kotlin.gradle.plugin.KotlinTarget
import org.jetbrains.kotlin.gradle.plugin.internal.state.TaskLoggers
import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinWithJavaTarget
import org.jetbrains.kotlin.gradle.plugin.mpp.isMain
import org.jetbrains.kotlin.gradle.plugin.statistics.KotlinBuildStatsService
import org.jetbrains.kotlin.gradle.tasks.AbstractKotlinCompile
import org.jetbrains.kotlin.gradle.tasks.GradleCompileTaskProvider
import org.jetbrains.kotlin.gradle.tasks.KotlinCompileTaskData
import org.jetbrains.kotlin.gradle.tasks.InspectClassesForMultiModuleIC
import org.jetbrains.kotlin.gradle.tasks.Kotlin2JsCompile
import org.jetbrains.kotlin.gradle.utils.archivePathCompatible
import org.jetbrains.kotlin.gradle.utils.newTmpFile
import org.jetbrains.kotlin.gradle.utils.relativeOrCanonical
@@ -213,50 +209,57 @@ internal open class GradleCompilerRunner(
val jarToClassListFile = HashMap<File, File>()
val jarToModule = HashMap<File, IncrementalModuleEntry>()
for (project in gradle.rootProject.allprojects) {
val multiplatformProjectTasks = mutableMapOf<Project, MutableSet<String>>()
if (project.kotlinExtensionOrNull == null)
continue
gradle.taskGraph.allTasks.forEach { task ->
val project = task.project
if (project.multiplatformExtensionOrNull != null) {
// Just record this, we'll process them later
val tasksInProject = multiplatformProjectTasks[project] ?: mutableSetOf()
tasksInProject.add(task.name)
multiplatformProjectTasks[project] = tasksInProject
}
val isMultiplatformProject = project.multiplatformExtensionOrNull != null
KotlinCompileTaskData.getTaskDataContainer(project).forEach { taskData ->
val compilation = taskData.compilation
val target = taskData.compilation.owner
if (task is AbstractKotlinCompile<*>) {
val module = IncrementalModuleEntry(
project.path,
compilation.ownModuleName,
task.moduleName.get(),
project.buildDir,
taskData.buildHistoryFile
task.buildHistoryFile.get().asFile
)
dirToModule[taskData.destinationDir.get()] = module
taskData.javaOutputDir?.let { dirToModule[it] = module }
dirToModule[task.destinationDir] = module
task.javaOutputDir.orNull?.asFile?.let { dirToModule[it] = module }
nameToModules.getOrPut(module.name) { HashSet() }.add(module)
if (compilation.platformType == KotlinPlatformType.js) {
jarForSourceSet(project, compilation.compilationPurpose)?.let {
if (task is Kotlin2JsCompile) {
jarForSourceSet(project, task.sourceSetName.get())?.let {
jarToModule[it] = module
}
}
} else if (task is InspectClassesForMultiModuleIC) {
jarToClassListFile[File(task.archivePath.get())] = task.classesListFile
}
}
if (compilation is KotlinCompilation<*> && target is KotlinTarget && compilation.isMain()) { // FIXME support PM20
if (isMultiplatformProject) {
try {
//It could cause task reconfiguration. TODO: fix it some day if need
// But using project.locateTask(taskName).configure cause an Exception for call from ImmutableActionSet
for ((project, tasksInProject) in multiplatformProjectTasks) {
project.extensions.findByType(KotlinMultiplatformExtension::class.java)?.let { kotlinExt ->
for (target in kotlinExt.targets) {
val mainCompilation = target.compilations.findByName(KotlinCompilation.MAIN_COMPILATION_NAME) ?: continue
val archiveTask = project.tasks.getByName(target.artifactsTaskName) as AbstractArchiveTask
jarToModule[archiveTask.archivePathCompatible.canonicalFile] = module
} catch (e: UnknownTaskException) {
//ignore not found task
}
} else {
if (target is KotlinWithJavaTarget<*>) {
val jar = project.tasks.getByName(target.artifactsTaskName) as Jar
jarToClassListFile[jar.archivePathCompatible.canonicalFile] = target.defaultArtifactClassesListFile.get()
}
if (mainCompilation.compileKotlinTaskName !in tasksInProject || target.artifactsTaskName !in tasksInProject) {
// tasks are not part of the task graph, skip
continue
}
val kotlinTask = mainCompilation.compileKotlinTask as? AbstractKotlinCompile<*> ?: continue
val module = IncrementalModuleEntry(
project.path,
kotlinTask.moduleName.get(),
project.buildDir,
kotlinTask.buildHistoryFile.get().asFile
)
val jarTask = project.tasks.findByName(target.artifactsTaskName) as? AbstractArchiveTask ?: continue
jarToModule[jarTask.archivePathCompatible.canonicalFile] = module
}
}
}
@@ -1,75 +0,0 @@
/*
* Copyright 2010-2019 JetBrains s.r.o. and Kotlin Programming Language contributors.
* 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.gradle.tasks
import org.gradle.api.Project
import org.gradle.api.plugins.ExtraPropertiesExtension
import org.gradle.api.provider.Property
import org.jetbrains.kotlin.gradle.plugin.KotlinCompilation
import org.jetbrains.kotlin.gradle.plugin.mpp.AbstractKotlinCompilation
import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.KotlinCompilationData
import org.jetbrains.kotlin.gradle.utils.getValue
import java.io.File
internal open class KotlinCompileTaskData(
val taskName: String,
@field:Transient // cannot be serialized for Gradle Instant Execution, but actually is not needed when a task is deserialized
val compilation: KotlinCompilationData<*>,
val destinationDir: Property<File>,
val useModuleDetection: Property<Boolean>
) {
private val project: Project
get() = compilation.project
private val taskBuildDirectory: File by project.provider {
File(File(compilation.project.buildDir, KOTLIN_BUILD_DIR_NAME), taskName)
}
//TODO
val buildHistoryFile: File by project.provider {
File(taskBuildDirectory, "build-history.bin")
}
var javaOutputDir: File? = null
companion object {
fun get(project: Project, taskName: String): KotlinCompileTaskData = project.getTaskDataMap().getValue(taskName)
fun getTaskDataContainer(project: Project): Iterable<KotlinCompileTaskData> =
project.getTaskDataMap().values.toSet()
fun register(
taskName: String,
compilation: KotlinCompilationData<*>
): KotlinCompileTaskData {
val project = compilation.project
val container = project.getTaskDataMap()
@Suppress("UnstableApiUsage")
return KotlinCompileTaskData(
taskName,
compilation,
project.objects.property(File::class.java).apply {
set(project.provider { error("destinationDir was not set for task ${project.path}$taskName") })
},
project.objects.property(Boolean::class.javaObjectType).apply { set(false) }
).also {
container[taskName] = it
}
}
private fun Project.getTaskDataMap(): MutableMap</* taskName: */ String, KotlinCompileTaskData> {
val ext = project.extensions.getByType(ExtraPropertiesExtension::class.java)
if (!ext.has(EXT_NAME)) {
ext.set(EXT_NAME, mutableMapOf<String, KotlinCompileTaskData>())
}
@Suppress("UNCHECKED_CAST")
return ext.get(EXT_NAME) as MutableMap<String, KotlinCompileTaskData>
}
private const val EXT_NAME = "kotlin.incremental.taskdata"
}
}