Skip to content

Commit

Permalink
Manage Kotlin native cache kind automatically based on Kotlin version (
Browse files Browse the repository at this point in the history
…#3477)

Set Kotlin/Native cache kind based on Kotlin version

Resolves #2046
Resolves #2386
  • Loading branch information
AlexeyTsvetkov authored Aug 11, 2023
1 parent 44376fd commit 950d5a9
Show file tree
Hide file tree
Showing 23 changed files with 439 additions and 58 deletions.
Original file line number Diff line number Diff line change
Expand Up @@ -13,7 +13,6 @@ import org.jetbrains.compose.internal.mppExtOrNull
import org.jetbrains.compose.internal.webExt
import org.jetbrains.kotlin.gradle.plugin.*
import org.jetbrains.kotlin.gradle.targets.js.ir.KotlinJsIrTarget
import java.lang.ClassCastException
import javax.inject.Inject

@Suppress("UnstableApiUsage")
Expand Down Expand Up @@ -48,24 +47,7 @@ class ComposeCompilerKotlinSupportPlugin @Inject constructor(
return !groupId.startsWith("org.jetbrains.compose.compiler")
}

val service = ComposeMultiplatformBuildService.provider(target)
buildEventsListenerRegistry.onTaskCompletion(service)

val providedService = try {
service.get()
} catch (e: ClassCastException) {
// Compose Gradle plugin was probably loaded more than once
// See https://github.com/JetBrains/compose-multiplatform/issues/3459

throw IllegalStateException(
"Failed to get ComposeMultiplatformBuildService instance." +
" Compose Gradle plugin was probably loaded more than once." +
" Consider declaring it in the root build.gradle.kts",
e
)
}

providedService.parameters.unsupportedCompilerPlugins.add(
ComposeMultiplatformBuildService.getInstance(target).unsupportedCompilerPlugins.add(
target.provider {
composeCompilerArtifactProvider.compilerArtifact.takeIf {
target.hasNonJvmTargets() && it.isNonJBComposeCompiler()
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -6,27 +6,32 @@ import org.gradle.api.provider.Provider
import org.gradle.api.provider.SetProperty
import org.gradle.api.services.BuildService
import org.gradle.api.services.BuildServiceParameters
import org.gradle.api.services.BuildServiceRegistry
import org.gradle.tooling.events.FinishEvent
import org.gradle.tooling.events.OperationCompletionListener
import org.jetbrains.compose.internal.utils.BuildEventsListenerRegistryProvider
import org.jetbrains.kotlin.gradle.plugin.SubpluginArtifact

// The service implements OperationCompletionListener just so Gradle would use the service
// even if the service is not used by any task or transformation
abstract class ComposeMultiplatformBuildService : BuildService<ComposeMultiplatformBuildService.Parameters>,
abstract class ComposeMultiplatformBuildService : BuildService<BuildServiceParameters.None>,
OperationCompletionListener, AutoCloseable {
interface Parameters : BuildServiceParameters {
val unsupportedCompilerPlugins: SetProperty<Provider<SubpluginArtifact?>>
}

private val log = Logging.getLogger(this.javaClass)

internal abstract val unsupportedCompilerPlugins: SetProperty<Provider<SubpluginArtifact?>>
internal abstract val delayedWarnings: SetProperty<String>

fun warnOnceAfterBuild(message: String) {
delayedWarnings.add(message)
}

override fun close() {
notifyAboutUnsupportedCompilerPlugin()
logDelayedWarnings()
}

private fun notifyAboutUnsupportedCompilerPlugin() {
val unsupportedCompilerPlugin = parameters.unsupportedCompilerPlugins.orNull
val unsupportedCompilerPlugin = unsupportedCompilerPlugins.orNull
?.firstOrNull()
?.orNull

Expand All @@ -35,28 +40,55 @@ abstract class ComposeMultiplatformBuildService : BuildService<ComposeMultiplatf
}
}

private fun logDelayedWarnings() {
for (warning in delayedWarnings.get()) {
log.warn(warning)
}
}

override fun onFinish(event: FinishEvent) {}

companion object {
fun configure(project: Project, fn: Parameters.() -> Unit): Provider<ComposeMultiplatformBuildService> =
project.gradle.sharedServices.registerOrConfigure<Parameters, ComposeMultiplatformBuildService> {
fn()
private val COMPOSE_SERVICE_FQ_NAME = ComposeMultiplatformBuildService::class.java.canonicalName

private fun findExistingComposeService(project: Project): ComposeMultiplatformBuildService? {
val registration = project.gradle.sharedServices.registrations.findByName(COMPOSE_SERVICE_FQ_NAME)
val service = registration?.service?.orNull
if (service != null) {
if (service !is ComposeMultiplatformBuildService) {
// Compose Gradle plugin was probably loaded more than once
// See https://github.com/JetBrains/compose-multiplatform/issues/3459
if (service.javaClass.canonicalName == ComposeMultiplatformBuildService::class.java.canonicalName) {
val rootScript = project.rootProject.buildFile
error("""
Compose Multiplatform Gradle plugin has been loaded in multiple classloaders.
To avoid classloading issues, declare Compose Gradle Plugin in root build file $rootScript.
""".trimIndent())
} else {
error("Shared build service '$COMPOSE_SERVICE_FQ_NAME' has unexpected type: ${service.javaClass.canonicalName}")
}
}
return service
}

fun provider(project: Project): Provider<ComposeMultiplatformBuildService> = configure(project) {}
return null
}

@Suppress("UnstableApiUsage")
fun init(project: Project) {
val existingService = findExistingComposeService(project)
if (existingService != null) {
return
}

val newService = project.gradle.sharedServices.registerIfAbsent(COMPOSE_SERVICE_FQ_NAME, ComposeMultiplatformBuildService::class.java) {
}
// workaround to instanciate a service even if it not binded to a task
BuildEventsListenerRegistryProvider.getInstance(project).onTaskCompletion(newService)
}

fun getInstance(project: Project): ComposeMultiplatformBuildService =
findExistingComposeService(project) ?: error("ComposeMultiplatformBuildService was not initialized!")
}
}

inline fun <reified P : BuildServiceParameters, reified S : BuildService<P>> BuildServiceRegistry.registerOrConfigure(
crossinline fn: P.() -> Unit
): Provider<S> {
val serviceClass = S::class.java
val serviceFqName = serviceClass.canonicalName
val existingService = registrations.findByName(serviceFqName)
?.apply { (parameters as? P)?.fn() }
?.service
return (existingService as? Provider<S>)
?: registerIfAbsent(serviceFqName, serviceClass) {
it.parameters.fn()
}
}
Original file line number Diff line number Diff line change
Expand Up @@ -21,6 +21,7 @@ import org.jetbrains.compose.desktop.preview.internal.initializePreview
import org.jetbrains.compose.experimental.dsl.ExperimentalExtension
import org.jetbrains.compose.experimental.internal.configureExperimentalTargetsFlagsCheck
import org.jetbrains.compose.experimental.internal.configureExperimental
import org.jetbrains.compose.experimental.internal.configureNativeCompilerCaching
import org.jetbrains.compose.experimental.uikit.internal.resources.configureSyncTask
import org.jetbrains.compose.internal.KOTLIN_MPP_PLUGIN_ID
import org.jetbrains.compose.internal.mppExt
Expand All @@ -35,8 +36,10 @@ import org.jetbrains.kotlin.gradle.plugin.KotlinPlatformType

internal val composeVersion get() = ComposeBuildConfig.composeVersion

class ComposePlugin : Plugin<Project> {
abstract class ComposePlugin : Plugin<Project> {
override fun apply(project: Project) {
ComposeMultiplatformBuildService.init(project)

val composeExtension = project.extensions.create("compose", ComposeExtension::class.java, project)
val desktopExtension = composeExtension.extensions.create("desktop", DesktopExtension::class.java)
val androidExtension = composeExtension.extensions.create("android", AndroidExtension::class.java)
Expand All @@ -52,6 +55,7 @@ class ComposePlugin : Plugin<Project> {
composeExtension.extensions.create("web", WebExtension::class.java)

project.plugins.apply(ComposeCompilerKotlinSupportPlugin::class.java)
project.configureNativeCompilerCaching()

project.afterEvaluate {
configureDesktop(project, desktopExtension)
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -7,7 +7,7 @@ package org.jetbrains.compose.desktop.application.internal

import org.gradle.api.provider.Provider
import org.gradle.api.provider.ProviderFactory
import org.jetbrains.compose.internal.utils.findProperty
import org.jetbrains.compose.internal.utils.valueOrNull
import org.jetbrains.compose.internal.utils.toBooleanProvider

internal object ComposeProperties {
Expand All @@ -23,32 +23,32 @@ internal object ComposeProperties {
internal const val CHECK_JDK_VENDOR = "compose.desktop.packaging.checkJdkVendor"

fun isVerbose(providers: ProviderFactory): Provider<Boolean> =
providers.findProperty(VERBOSE).toBooleanProvider(false)
providers.valueOrNull(VERBOSE).toBooleanProvider(false)

fun preserveWorkingDir(providers: ProviderFactory): Provider<Boolean> =
providers.findProperty(PRESERVE_WD).toBooleanProvider(false)
providers.valueOrNull(PRESERVE_WD).toBooleanProvider(false)

fun macSign(providers: ProviderFactory): Provider<Boolean> =
providers.findProperty(MAC_SIGN).toBooleanProvider(false)
providers.valueOrNull(MAC_SIGN).toBooleanProvider(false)

fun macSignIdentity(providers: ProviderFactory): Provider<String?> =
providers.findProperty(MAC_SIGN_ID)
providers.valueOrNull(MAC_SIGN_ID)

fun macSignKeychain(providers: ProviderFactory): Provider<String?> =
providers.findProperty(MAC_SIGN_KEYCHAIN)
providers.valueOrNull(MAC_SIGN_KEYCHAIN)

fun macSignPrefix(providers: ProviderFactory): Provider<String?> =
providers.findProperty(MAC_SIGN_PREFIX)
providers.valueOrNull(MAC_SIGN_PREFIX)

fun macNotarizationAppleID(providers: ProviderFactory): Provider<String?> =
providers.findProperty(MAC_NOTARIZATION_APPLE_ID)
providers.valueOrNull(MAC_NOTARIZATION_APPLE_ID)

fun macNotarizationPassword(providers: ProviderFactory): Provider<String?> =
providers.findProperty(MAC_NOTARIZATION_PASSWORD)
providers.valueOrNull(MAC_NOTARIZATION_PASSWORD)

fun macNotarizationAscProvider(providers: ProviderFactory): Provider<String?> =
providers.findProperty(MAC_NOTARIZATION_ASC_PROVIDER)
providers.valueOrNull(MAC_NOTARIZATION_ASC_PROVIDER)

fun checkJdkVendor(providers: ProviderFactory): Provider<Boolean> =
providers.findProperty(CHECK_JDK_VENDOR).toBooleanProvider(true)
providers.valueOrNull(CHECK_JDK_VENDOR).toBooleanProvider(true)
}
Original file line number Diff line number Diff line change
@@ -0,0 +1,114 @@
/*
* Copyright 2020-2023 JetBrains s.r.o. and respective authors and developers.
* Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE.txt file.
*/

package org.jetbrains.compose.experimental.internal

import org.gradle.api.Project
import org.jetbrains.compose.ComposeMultiplatformBuildService
import org.jetbrains.compose.internal.KOTLIN_MPP_PLUGIN_ID
import org.jetbrains.compose.internal.mppExt
import org.jetbrains.compose.internal.utils.KGPPropertyProvider
import org.jetbrains.compose.internal.utils.configureEachWithType
import org.jetbrains.kotlin.gradle.plugin.getKotlinPluginVersion
import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinNativeTarget
import org.jetbrains.kotlin.konan.target.presetName

private const val PROJECT_CACHE_KIND_PROPERTY_NAME = "kotlin.native.cacheKind"
private const val COMPOSE_NATIVE_MANAGE_CACHE_KIND = "compose.kotlin.native.manageCacheKind"
private const val NONE_VALUE = "none"

internal fun Project.configureNativeCompilerCaching() {
if (findProperty(COMPOSE_NATIVE_MANAGE_CACHE_KIND) == "false") return

plugins.withId(KOTLIN_MPP_PLUGIN_ID) {
val kotlinVersion = kotlinVersionNumbers(this)
mppExt.targets.configureEachWithType<KotlinNativeTarget> {
checkCacheKindUserValueIsNotNone()
configureTargetCompilerCache(kotlinVersion)
}
}
}

private fun KotlinNativeTarget.checkCacheKindUserValueIsNotNone() {
// To determine cache kind KGP checks kotlin.native.cacheKind.<PRESET_NAME> first, then kotlin.native.cacheKind
// For each property it tries to read Project.property, then checks local.properties
// See https://github.com/JetBrains/kotlin/blob/d4d30dcfcf1afb083f09279c6f1ba05031efeabb/libraries/tools/kotlin-gradle-plugin/src/common/kotlin/org/jetbrains/kotlin/gradle/plugin/PropertiesProvider.kt#L416
val cacheKindProperties = listOf(targetCacheKindPropertyName, PROJECT_CACHE_KIND_PROPERTY_NAME)
val propertyProviders = listOf(
KGPPropertyProvider.GradleProperties(project),
KGPPropertyProvider.LocalProperties(project)
)

for (cacheKindProperty in cacheKindProperties) {
for (provider in propertyProviders) {
val value = provider.valueOrNull(cacheKindProperty)
if (value != null) {
if (value.equals(NONE_VALUE, ignoreCase = true)) {
ComposeMultiplatformBuildService
.getInstance(project)
.warnOnceAfterBuild(cacheKindPropertyWarningMessage(cacheKindProperty, provider))
}
return
}
}
}
}

private fun cacheKindPropertyWarningMessage(
cacheKindProperty: String,
provider: KGPPropertyProvider
) = """
|Warning: '$cacheKindProperty' is explicitly set to `none`.
|This option significantly slows the Kotlin/Native compiler.
|Compose Multiplatform Gradle plugin can set this property automatically,
|when it is necessary.
| * Recommended action: remove explicit '$cacheKindProperty=$NONE_VALUE' from ${provider.location}.
| * Alternative action: if you are sure you need '$cacheKindProperty=$NONE_VALUE', disable
|this warning by adding '$COMPOSE_NATIVE_MANAGE_CACHE_KIND=false' to your 'gradle.properties'.
""".trimMargin()

private fun KotlinNativeTarget.configureTargetCompilerCache(kotlinVersion: KotlinVersion) {
// See comments in https://youtrack.jetbrains.com/issue/KT-57329
when {
// Kotlin < 1.9.0 => disable cache
kotlinVersion < KotlinVersion(1, 9, 0) -> {
disableKotlinNativeCache()
}
// 1.9.0 <= Kotlin < 1.9.20 => add -Xlazy-ir-for-caches=disable
kotlinVersion < KotlinVersion(1, 9, 20) -> {
disableLazyIrForCaches()
}
// Kotlin >= 1.9.20 => do nothing
else -> {}
}
}

private val KotlinNativeTarget.targetCacheKindPropertyName: String
get() = "$PROJECT_CACHE_KIND_PROPERTY_NAME.${konanTarget.presetName}"

private fun KotlinNativeTarget.disableKotlinNativeCache() {
if (project.hasProperty(targetCacheKindPropertyName)) {
project.setProperty(targetCacheKindPropertyName, NONE_VALUE)
} else {
project.extensions.extraProperties.set(targetCacheKindPropertyName, NONE_VALUE)
}
}

private fun KotlinNativeTarget.disableLazyIrForCaches() {
compilations.configureEach { compilation ->
compilation.kotlinOptions.freeCompilerArgs += listOf("-Xlazy-ir-for-caches=disable")
}
}

private fun kotlinVersionNumbers(project: Project): KotlinVersion {
val version = project.getKotlinPluginVersion()
val m = Regex("(\\d+)\\.(\\d+)\\.(\\d+)").find(version) ?: error("Kotlin version has unexpected format: '$version'")
val (_, majorPart, minorPart, patchPart) = m.groupValues
return KotlinVersion(
major = majorPart.toIntOrNull() ?: error("Could not parse major part '$majorPart' of Kotlin plugin version: '$version'"),
minor = minorPart.toIntOrNull() ?: error("Could not parse minor part '$minorPart' of Kotlin plugin version: '$version'"),
patch = patchPart.toIntOrNull() ?: error("Could not parse patch part '$patchPart' of Kotlin plugin version: '$version'"),
)
}
Original file line number Diff line number Diff line change
Expand Up @@ -7,12 +7,12 @@ package org.jetbrains.compose.experimental.uikit.internal.utils

import org.gradle.api.provider.Provider
import org.gradle.api.provider.ProviderFactory
import org.jetbrains.compose.internal.utils.findProperty
import org.jetbrains.compose.internal.utils.valueOrNull
import org.jetbrains.compose.internal.utils.toBooleanProvider

internal object IosGradleProperties {
const val SYNC_RESOURCES_PROPERTY = "org.jetbrains.compose.ios.resources.sync"

fun syncResources(providers: ProviderFactory): Provider<Boolean> =
providers.findProperty(SYNC_RESOURCES_PROPERTY).toBooleanProvider(true)
providers.valueOrNull(SYNC_RESOURCES_PROPERTY).toBooleanProvider(true)
}
Original file line number Diff line number Diff line change
@@ -0,0 +1,18 @@
/*
* Copyright 2020-2023 JetBrains s.r.o. and respective authors and developers.
* Use of this source code is governed by the Apache 2.0 license that can be found in the LICENSE.txt file.
*/

package org.jetbrains.compose.internal.utils

import org.gradle.api.Project
import org.gradle.build.event.BuildEventsListenerRegistry
import javax.inject.Inject

@Suppress("UnstableApiUsage")
internal abstract class BuildEventsListenerRegistryProvider @Inject constructor(val registry: BuildEventsListenerRegistry) {
companion object {
fun getInstance(project: Project): BuildEventsListenerRegistry =
project.objects.newInstance(BuildEventsListenerRegistryProvider::class.java).registry
}
}
Loading

0 comments on commit 950d5a9

Please sign in to comment.