Currently when `org.gradle.configuration-cache=true` we have an error:
> Configuration cache state could not be cached: field `resourceFiles`
of task `:shared:syncComposeResourcesForIos` of type
`org.jetbrains.compose.experimental.uikit.tasks.SyncComposeResourcesForIosTask`:
error writing value of type
'org.gradle.api.internal.provider.TransformBackedProvider'
Old description (can be ignored):
_This PR attempts to fix it in SyncComposeResourcesForIosTask by
wrapping inputs into providers. It seems that gradle configuration cache
doesn't like some provider types produced by `.map`, `.zip`, `.orElse`,
etc._
**Latest description:**
With configuration cache enabled, gradle runs all `orElse` providers
during configuration (I don't know why yet).
We used to throw an exception in `orElse` which led to the crash. This
PR refactors SyncComposeResourcesForIosTask so it doesn't throw an
exception immediately in orElse, but postpones it to later step.
* Add API to not apply the Compose Compiler plugin
* avoid eager initialization
* Update gradle-plugins/compose/src/main/kotlin/org/jetbrains/compose/ComposeExtension.kt
Co-authored-by: Igor Demin <igordmn@users.noreply.github.com>
* Update gradle-plugins/compose/src/main/kotlin/org/jetbrains/compose/ComposeExtension.kt
Co-authored-by: Igor Demin <igordmn@users.noreply.github.com>
* Apply PR review suggestions:
- Deprecate `compose.web.targets` in favor of `compose.platformTypes`
- refactor `configureExperimentalWebApplication` to support multiple k/js targets
---------
Co-authored-by: Igor Demin <igordmn@users.noreply.github.com>
* Update versions to CM 1.5.1 and kotlin 1.9.10
* Add explicit dependencies on compose.ui and compose.foundation in examples/chat/jsApp
* Update CHANGELOG.md
* fix typo
* Add Dependencies for 1.5.1 Changelog
Sometimes we need to report warnings during the configuration phase.
For example, when Androidx Compose Compiler is used with
non-JVM targets (e.g. iOS/js), we want to warn users
that using non-JB compiler with non-JVM targets is not supported.
The default way of reporting warnings in Gradle is using a logger.
For example we could write something like:
```
abstract class ComposePlugin : Plugin<Project> {
override fun apply(project: Project) {
if (project.hasNonJvmTargets() && project.usesNonJBComposeCompiler()) {
project.logger.warn("...")
}
}
}
```
This approach has a few issues:
1. When the Configuration Cache is enabled, project's configuration might
get skipped altogether, and the warning won't be printed.
2. If a project contains multiple Gradle modules (subprojects),
the warning might be printed multiple times. That might be OK
for some warnings. But repeating exactly the same warning
10s or 100s is unnecessary.
The only way to share the state between Gradle modules,
while preserving compatibility with the Configuration Cache,
is to define Gradle Build Service.
In 1.5.0 we used Gradle Build Service mechanism for both warnings.
However, I did not know that:
* only the service's parameters are persisted in the Configuration Cache.
The service itself is not persisted.
* if a service instance is materialized during the configuration
phase, then all changes made to its parameters will not be
visible to that particular instance (but they will be visible to the
next instance).
So the only way to report diagnostics with configuration cache without
repetition is to define a service that is not materialized
during the configuration phase (i.e. serviceProvider.get() is not called),
add to add warnings to a set property of the service.
This change implements that.
Resolves#3595
The new android multiplatform plugin will have type `jvm` but doesn't
inherit from the KotlinJvmTarget type, which makes the compose
multiplatform gradle plugin not useable with the new android gradle
plugin for multiplatforms builds.
* Fix cache kind management with nested subprojects
Previously, cache kind property management
worked incorrectly when Compose Gradle plugin
was applied to both parent and child subprojects,
e.g. :compose-subproject-1:compose-subproject-2.
With this example the plugin would successfully
set the property for compose-subproject-1,
but then for compose-subproject-2 the following snippet
would fail:
```
if (project.hasProperty(targetCacheKindPropertyName)) {
project.setProperty(targetCacheKindPropertyName, NONE_VALUE)
}
```
because project.hasProperty would have return true
(because it checks parent subproject properties too),
but project.setProperty would fail, because
parent project's properties are read only.
Warnings were also handled incorrectly in this case,
because during the configuration of compose-subproject-1 we might set
`kotlin.native.cacheKind.ios*=none`,
which would then cause a warning during the configuration of compose-subproject-2.
To avoid incorrect warnings, we now
record the snapshot of relevant properties
during Compose Multiplatform build service initialization
Resolves#3515
* Fix issues from code review
For iOS/Web it will be stabilized with stabilizing these targets themselves. Also, we should expose uiTest for them, not uiTestJUnit4
JUnit5 support will be provided in the future in [this issue](https://github.com/JetBrains/compose-multiplatform/issues/2371)
## API Changes
- Testing framework is stabilized for Desktop
- `compose.uiTestJUnit4` is renamed to `compose.desktop.uiTestJUnit4`
We tried to enable the compiler cache, when
Kotlin/Native 1.9.0 is used.
Prior to Kotlin 1.9.0, the caching could not
be used with Compose, because code generation would fail.
With Kotlin 1.9.0, code generation succeeds, but generated debug symbols cause issues with dsymutil during xcode build.
For more details, see https://youtrack.jetbrains.com/issue/KT-61270
This change partially reverts https://github.com/JetBrains/compose-multiplatform/pull/3477 and https://github.com/JetBrains/compose-multiplatform/pull/3496
Now, we always set `kotlin.native.cacheKind=none` in
Compose Multiplatform Gradle plugin for all
versions of Kotlin until KT-61270 is fixed.
Also, explicit cache kind error becomes a warning again.
It updates the default version of compose compiler plugin for kotlin 1.9.0
For now it's 1.5.1-rc01 version. For a stable release, we'll build a stable 1.5.1 compose compiler plugin.
* Handle ClassCastException for ComposeMultiplatformBuildService in Compose Gradle plugin
ClassCastException might occur when our gradle plugin was loaded more than once. See https://github.com/JetBrains/compose-multiplatform/issues/3459
We throw another exception with a bit more clear message.
* Update gradle-plugins/compose/src/main/kotlin/org/jetbrains/compose/ComposeCompilerKotlinSupportPlugin.kt
Compose compiler plugin produces symbols with identical signatures. k/jvm and k/native do not check for clashes, while k/js does. We disable the checker in our gradle plugin, so our users do not need to add extra workaround on their side.
* Simplify resource management for iOS
Introduces new a new task 'sync<FRAMEWORK_CLASSIFIER>ComposeIosResources',
which collects resources from all source sets, included in iOS targets.
With this change:
* CocoaPods integration does not require any configuration or calling 'pod install' after changing resources.
* Important: existing projects need to remove 'extraSpecAttributes["resources"] = ...' from build scripts, and rerun `./gradlew podInstall` once!
* Without CocoaPods, the resource directory should be added to XCode build phases once.
Resolves#3073Resolves#3113Resolves#3066
* Add a warning for a user who sets `compose.kotlinCompilerPlugin` to `android.compose.compiler.compiler`
The warning will show up only when a multiplatform project contains at least one of the non-jvm targets: k/js, k/native or k/wasm
* fix typo
* PR review
* Refactor to BuildService
* fix typo
* Improve error messages when checking tasks
Previously some errors in checkRuntime task
were reported as a nested exception.
By default, Gradle shows only top-level
error message of an exception, which
made some errors confusing.
For example, when javac was missing from JDK,
Gradle only showed "Could not infer Java runtime version for Java home directory".
The part that said javac was missing was only shown,
when Gradle was run with --stacktrace argument.
This is suboptimal UX, so this commit refactors
checkRuntime to make error messages more descriptive.
#3133
* Handle JDK 1.8 correctly
* Prebuild jdk version probe
* Fix signing bundle with Gradle 8.1 with configuration cache
Compose Gradle plugin was launching
`/usr/bin/security --find-identity` in a lazy property of
AbstractJPackageTask. Without the configuration cache
the computation was delayed to the execution phase.
However, configuration cache serializes all properties of
all configured tasks, so launching of `/usr/bin/security`
shifted to the configuration phase.
Gradle 8.1 started to throw an exception if an external process is
launched during configuration time.
This change explicitly moves the call to
`/usr/bin/security` to the execution phase.
Resolves#3060
* Turn off Gradle configuration cache for one test
Oleksandr Karpovich
dima.avdeev
Alexey Tsvetkov
Nikolai Rykunov
Amr Afifiy
Igor Demin
Igor Demin
dima.avdeev