org.jetbrains.kotlin.gradle.targets.native.internal.CommonizerTasks.kt Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of kotlin-gradle-plugin Show documentation
Kotlin Gradle Plugin
There is a newer version: 2.1.0-Beta1
/*
 * Copyright 2010-2021 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.targets.native.internal

import org.gradle.api.Project
import org.gradle.api.Task
import org.gradle.api.tasks.Delete
import org.gradle.api.tasks.TaskProvider
import org.jetbrains.kotlin.gradle.internal.isInIdeaSync
import org.jetbrains.kotlin.gradle.plugin.PropertiesProvider
import org.jetbrains.kotlin.gradle.plugin.whenEvaluated
import org.jetbrains.kotlin.gradle.tasks.dependsOn
import org.jetbrains.kotlin.gradle.tasks.locateTask
import org.jetbrains.kotlin.gradle.tasks.registerTask

internal val Project.isCInteropCommonizationEnabled: Boolean get() = PropertiesProvider(this).enableCInteropCommonization

internal val Project.isIntransitiveMetadataConfigurationEnabled: Boolean
    get() = PropertiesProvider(this).enableIntransitiveMetadataConfiguration

internal val Project.commonizeTask: TaskProvider
    get() = locateOrRegisterTask(
        "commonize",
        invokeWhenRegistered = { @Suppress("deprecation") runCommonizerTask.dependsOn(this) },
        configureTask = {
            group = "interop"
            description = "Aggregator task for all c-interop & Native distribution commonizer tasks"
        }
    )

/**
 * Keeping this task/task name for IDE compatibility which is invoking 'runCommonizer' during sync
 */
@Deprecated("Use 'commonizeTask' instead. Keeping the task for IDE compatibility", replaceWith = ReplaceWith("commonizeTask"))
internal val Project.runCommonizerTask: TaskProvider
    get() = locateOrRegisterTask(
        "runCommonizer",
        invokeWhenRegistered = { dependsOn(commonizeTask) },
        configureTask = {
            group = "interop"
            description = "[Deprecated: Use 'commonize' instead]"
        }
    )

internal val Project.commonizeCInteropTask: TaskProvider?
    get() {
        if (isCInteropCommonizationEnabled) {
            return locateOrRegisterTask(
                "commonizeCInterop",
                invokeWhenRegistered = {
                    val task = this
                    commonizeTask.dependsOn(this)
                    whenEvaluated {
                        commonizeNativeDistributionTask?.let(task::dependsOn)
                    }
                },
                configureTask = {
                    group = "interop"
                    description = "Invokes the commonizer on c-interop bindings of the project"
                }
            )
        }
        return null
    }

internal val Project.copyCommonizeCInteropForIdeTask: TaskProvider?
    get() {
        val commonizeCInteropTask = commonizeCInteropTask
        if (commonizeCInteropTask != null) {
            return locateOrRegisterTask(
                "copyCommonizeCInteropForIde",
                invokeWhenRegistered = { if (isInIdeaSync) commonizeTask.dependsOn(this) },
                configureTask = {
                    group = "interop"
                    description = "Copies the output of ${commonizeCInteropTask.get().name} into " +
                            "the root projects .gradle folder for the IDE"
                }
            )
        }
        return null
    }

internal val Project.commonizeNativeDistributionTask: TaskProvider?
    get() {
        if (!isAllowCommonizer()) return null
        return rootProject.locateOrRegisterTask(
            "commonizeNativeDistribution",
            invokeWhenRegistered = { rootProject.commonizeTask.dependsOn(this); cleanNativeDistributionCommonizerTask },
            configureTask = {
                group = "interop"
                description = "Invokes the commonizer on platform libraries provided by the Kotlin/Native distribution"
            }
        )
    }

internal val Project.cleanNativeDistributionCommonizerTask: TaskProvider?
    get() {
        val commonizeNativeDistributionTask = commonizeNativeDistributionTask ?: return null
        return rootProject.locateOrRegisterTask(
            "cleanNativeDistributionCommonization",
            configureTask = {
                group = "interop"
                description = "Deletes all previously commonized klib's from the Kotlin/Native distribution"
                delete(commonizeNativeDistributionTask.map { it.getRootOutputDirectory() })
            }
        )
    }

private inline fun  Project.locateOrRegisterTask(
    name: String,
    args: List = emptyList(),
    invokeWhenRegistered: (TaskProvider.() -> Unit) = {},
    noinline configureTask: (T.() -> Unit)? = null
): TaskProvider {
    locateTask(name)?.let { return it }
    return registerTask(name, args, configureTask).also(invokeWhenRegistered)
}