Update KGP to 2.2 (#5293)

Compose gradle plugin now depends on Kotlin gradle plugin 2.2

## Release Notes
### Migration Notes - Gradle Plugin
- The compose gradle plugin requires Kotlin gradle plugin 2.+ version
now. Old `org.jetbrains.compose.compiler` is not supported anymore and
the API to configure it was removed.

Author: terrakok

.github/workflows/gradle-plugin.yml

@@ -16,9 +16,9 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [ubuntu-24.04, macos-14, windows-2022]
-        gradle: [7.4, 8.13]
-        agp: [8.6.0, 8.9.0]
+        os: ['ubuntu-24.04', 'macos-14', 'windows-2022']
+        gradle: ['8.7', '8.13']
+        agp: ['8.6.0', '8.9.0']
     runs-on: ${{ matrix.os }}
     steps:
       - uses: actions/checkout@v4

gradle-plugins/build.gradle.kts

@@ -34,8 +34,9 @@ subprojects {
             compilerOptions {
                 // must be set to a language version of the kotlin compiler & runtime,
                 // which is bundled to the oldest supported Gradle
-                languageVersion.set(KotlinVersion.KOTLIN_1_6)
-                apiVersion.set(KotlinVersion.KOTLIN_1_6)
+                // https://docs.gradle.org/current/userguide/compatibility.html#kotlin
+                languageVersion.set(KotlinVersion.KOTLIN_1_8)
+                apiVersion.set(KotlinVersion.KOTLIN_1_8)
                 jvmTarget.set(JvmTarget.JVM_11)
             }
         }

gradle-plugins/compose/build.gradle.kts

@@ -94,6 +94,7 @@ val jar = tasks.named<Jar>("jar") {
 
 val supportedGradleVersions = project.propertyList("compose.tests.gradle.versions")
 val supportedAgpVersions = project.propertyList("compose.tests.agp.versions")
+val excludedGradleAgpVersions = project.propertyList("compose.tests.gradle-agp.exclude")
 
 fun Project.propertyList(name: String) =
     project.property(name).toString()
@@ -175,9 +176,8 @@ for (gradleVersion in supportedGradleVersions) {
              * > Failed to apply plugin 'com.android.internal.version-check'.
              * > Minimum supported Gradle version is 8.2. Current version is 7.4.
              */
-            val agpMajor = agpVersion.split('.').first().toInt()
-            val gradleMajor = gradleVersion.split('.').first().toInt()
-            onlyIf { agpMajor <= gradleMajor }
+            val isExcluded = excludedGradleAgpVersions.contains("$gradleVersion/$agpVersion")
+            onlyIf { !isExcluded }
 
             systemProperty("compose.tests.gradle.test.jdks.root", jdkForTestsRoot.absolutePath)
             systemProperty("compose.tests.gradle.version", gradleVersion)

gradle-plugins/compose/src/main/kotlin/org/jetbrains/compose/CheckComposeCompilerPlugin.kt

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2020-2021 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
+
+import org.gradle.api.Project
+import org.jetbrains.compose.internal.KOTLIN_ANDROID_PLUGIN_ID
+import org.jetbrains.compose.internal.KOTLIN_JS_PLUGIN_ID
+import org.jetbrains.compose.internal.KOTLIN_JVM_PLUGIN_ID
+import org.jetbrains.compose.internal.KOTLIN_MPP_PLUGIN_ID
+import org.jetbrains.compose.internal.Version
+import org.jetbrains.compose.internal.ideaIsInSyncProvider
+import org.jetbrains.kotlin.gradle.plugin.KotlinBasePlugin
+
+internal fun Project.checkComposeCompilerPlugin() {
+    //only one of them can be applied to the project
+    listOf(
+        KOTLIN_MPP_PLUGIN_ID,
+        KOTLIN_JVM_PLUGIN_ID,
+        KOTLIN_ANDROID_PLUGIN_ID,
+        KOTLIN_JS_PLUGIN_ID
+    ).forEach { pluginId ->
+        plugins.withId(pluginId) { plugin ->
+            checkComposeCompilerPlugin(plugin as KotlinBasePlugin)
+        }
+    }
+}
+
+internal const val minimalSupportedKgpVersionError = "e: Configuration problem: " +
+        "Minimal supported Kotlin Gradle Plugin version is 2.0.0"
+internal const val newCompilerIsAvailableVersion = "2.0.0"
+internal const val newComposeCompilerKotlinSupportPluginId = "org.jetbrains.kotlin.plugin.compose"
+internal const val newComposeCompilerError =
+    "Since Kotlin 2.0.0 to use Compose Multiplatform " +
+            "you must apply \"$newComposeCompilerKotlinSupportPluginId\" plugin." +
+            "\nSee the migration guide https://www.jetbrains.com/help/kotlin-multiplatform-dev/compose-compiler.html#migrating-a-compose-multiplatform-project"
+
+private fun Project.checkComposeCompilerPlugin(kgp: KotlinBasePlugin) {
+    val kgpVersion = kgp.pluginVersion
+    val ideaIsInSync = project.ideaIsInSyncProvider().get()
+
+    if (Version.fromString(kgpVersion) < Version.fromString(newCompilerIsAvailableVersion)) {
+        if (ideaIsInSync) logger.error(minimalSupportedKgpVersionError)
+        else error(minimalSupportedKgpVersionError)
+    } else {
+        //There is no other way to check that the plugin WASN'T applied!
+        afterEvaluate {
+            logger.info("Check that new '$newComposeCompilerKotlinSupportPluginId' was applied")
+            if (!project.plugins.hasPlugin(newComposeCompilerKotlinSupportPluginId)) {
+                if (ideaIsInSync) logger.error("e: Configuration problem: $newComposeCompilerError")
+                else error("e: Configuration problem: $newComposeCompilerError")
+            }
+        }
+    }
+}

gradle-plugins/compose/src/main/kotlin/org/jetbrains/compose/ComposeCompilerCompatibility.kt

@@ -28,7 +28,6 @@ import org.jetbrains.compose.resources.configureComposeResources
 import org.jetbrains.compose.web.WebExtension
 import org.jetbrains.compose.web.internal.configureWeb
 import org.jetbrains.kotlin.gradle.plugin.KotlinDependencyHandler
-import org.jetbrains.kotlin.gradle.plugin.getKotlinPluginVersion
 
 internal val composeVersion get() = ComposeBuildConfig.composeVersion
 
@@ -49,7 +48,7 @@ abstract class ComposePlugin : Plugin<Project> {
         project.initializePreview(desktopExtension)
         composeExtension.extensions.create("web", WebExtension::class.java)
 
-        project.configureComposeCompilerPlugin()
+        project.checkComposeCompilerPlugin()
 
         project.configureComposeResources(resourcesExtension)
 
@@ -66,7 +65,6 @@ abstract class ComposePlugin : Plugin<Project> {
     @Suppress("DEPRECATION")
     class Dependencies(project: Project) {
         val desktop = DesktopDependencies
-        val compiler = CompilerDependencies(project)
         val animation get() = composeDependency("org.jetbrains.compose.animation:animation")
         val animationGraphics get() = composeDependency("org.jetbrains.compose.animation:animation-graphics")
         val foundation get() = composeDependency("org.jetbrains.compose.foundation:foundation")
@@ -109,16 +107,6 @@ abstract class ComposePlugin : Plugin<Project> {
         }
     }
 
-    class CompilerDependencies(private val project: Project) {
-        fun forKotlin(version: String) = "org.jetbrains.compose.compiler:compiler:" +
-                ComposeCompilerCompatibility.compilerVersionFor(version)
-
-        /**
-         * Compose Compiler that is chosen by the version of Kotlin applied to the Gradle project
-         */
-        val auto get() = forKotlin(project.getKotlinPluginVersion())
-    }
-
     object CommonComponentsDependencies {
         val resources = composeDependency("org.jetbrains.compose.components:components-resources")
         val uiToolingPreview = composeDependency("org.jetbrains.compose.components:components-ui-tooling-preview")