Allow to use Compose on multiple Kotlin versions

README.md

@@ -72,4 +72,6 @@ Note that when you use Compose Multiplatform, you setup your project differently
 
 ## Getting latest version of Compose Multiplatform ##
 
-See https://github.com/JetBrains/compose-jb/releases/latest for the latest stable release or https://github.com/JetBrains/compose-jb/releases for all stable and dev releases.
+See [this page](https://github.com/JetBrains/compose-jb/releases/latest) to know the latest stable release or [this](https://github.com/JetBrains/compose-jb/releases) to know all stable and dev releases.
+
+See also [more information](VERSIONING.md) about compatability and versioning. The changelog you can find [here](CHANGELOG.md).

FEATURES.md → VERSIONING.md

@@ -21,12 +21,13 @@ Knowing issues on older versions:
 
 ### Kotlin compatibility
 
-Compose version | Kotlin version
---- | ---
-1.0.0+ | 1.5.31
-1.0.1-rc2+ | 1.6.10
-
+When the new version of Kotlin is released, the latest Compose Multiplatform version isn't supported yet.
 
-### Gradle plugin compatibility
+But after some time we will release a version which supports the latest Kotlin.
+Starting from 1.2.0, Compose Multiplatform supports multiple versions of Kotlin.
 
-* 1.0.0 works with Gradle 6.7 or later (7.2 is the latest tested version).
+Compose version | Kotlin version
+--- | ---
+1.0.0 | 1.5.31
+1.1.1 | 1.6.20
+1.2.0 | 1.7.10 - 1.7.20 (Desktop, Android), 1.7.10 (JS)

examples/validateExamples.sh

@@ -25,7 +25,4 @@ runGradle issues package
 runGradle notepad package
 runGradle todoapp-lite package
 runGradle visual-effects package
-runGradle web-compose-bird build
-runGradle web-landing build
-runGradle web-with-react build
 runGradle widgets-gallery package

examples/validateExamplesWithJs.sh

@@ -0,0 +1,24 @@
+#!/bin/bash
+
+# Script to build most of the examples, to verify if they can compile.
+# Don't add examples, which don't depend on maven.pkg.jetbrains.space, because they won't be able to compile.
+
+set -euo pipefail
+
+if [ "$#" -ne 2 ]; then
+echo "Specify Compose and Kotlin version. For example: ./validateExamplesWithJs.sh 1.1.1 1.6.10"
+exit 1
+fi
+COMPOSE_VERSION=$1
+KOTLIN_VERSION=$2
+
+
+runGradle() {
+    pushd $1
+    ./gradlew $2 -Pcompose.version=$COMPOSE_VERSION -Pkotlin.version=$KOTLIN_VERSION
+    popd
+}
+
+runGradle web-compose-bird build
+runGradle web-landing build
+runGradle web-with-react build

gradle-plugins/buildSrc/src/main/kotlin/BuildProperties.kt

@@ -15,10 +15,6 @@ object BuildProperties {
     fun composeVersion(project: Project): String =
         System.getenv("COMPOSE_GRADLE_PLUGIN_COMPOSE_VERSION")
             ?: project.findProperty("compose.version") as String
-    fun composeCompilerVersion(project: Project): String =
-        project.findProperty("compose.compiler.version") as String
-    fun composeCompilerCompatibleKotlinVersion(project: Project): String =
-        project.findProperty("compose.compiler.compatible.kotlin.version") as String
     fun testsAndroidxCompilerVersion(project: Project): String =
         project.findProperty("compose.tests.androidx.compiler.version") as String
     fun testsAndroidxCompilerCompatibleVersion(project: Project): String =

gradle-plugins/compose/build.gradle.kts

@@ -29,7 +29,6 @@ val buildConfig = tasks.register("buildConfig", GenerateBuildConfig::class.java)
     classFqName.set("org.jetbrains.compose.ComposeBuildConfig")
     generatedOutputDir.set(buildConfigDir)
     fieldsToGenerate.put("composeVersion", BuildProperties.composeVersion(project))
-    fieldsToGenerate.put("composeCompilerVersion", BuildProperties.composeCompilerVersion(project))
     fieldsToGenerate.put("composeGradlePluginVersion", BuildProperties.deployVersion(project))
     fieldsToGenerate.put("experimentalOELPublication", BuildProperties.experimentalOELPublication(project))
     fieldsToGenerate.put("oelAndroidXVersion", BuildProperties.oelAndroidXVersion(project).orEmpty())

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

@@ -0,0 +1,14 @@
+package org.jetbrains.compose
+
+internal object ComposeCompilerCompatability {
+    fun compilerVersionFor(kotlinVersion: String): ComposeCompilerVersion? = when (kotlinVersion) {
+        "1.7.10" -> ComposeCompilerVersion("1.3.0-alpha01")
+        "1.7.20" -> ComposeCompilerVersion("1.3.2-alpha01", isJsSupported = false)
+        else -> null
+    }
+}
+
+internal data class ComposeCompilerVersion(
+    val version: String,
+    val isJsSupported: Boolean = true
+)

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

@@ -13,13 +13,18 @@ import org.jetbrains.kotlin.gradle.plugin.*
 import org.jetbrains.kotlin.gradle.targets.js.ir.KotlinJsIrTarget
 
 class ComposeCompilerKotlinSupportPlugin : KotlinCompilerPluginSupportPlugin {
-    private var composeCompilerArtifactProvider = ComposeCompilerArtifactProvider { null }
+    private lateinit var composeCompilerArtifactProvider: ComposeCompilerArtifactProvider
 
     override fun apply(target: Project) {
         super.apply(target)
         target.plugins.withType(ComposePlugin::class.java) {
             val composeExt = target.extensions.getByType(ComposeExtension::class.java)
-            composeCompilerArtifactProvider = ComposeCompilerArtifactProvider { composeExt.kotlinCompilerPlugin.orNull }
+
+            composeCompilerArtifactProvider = ComposeCompilerArtifactProvider(
+                kotlinVersion = target.getKotlinPluginVersion()
+            ) {
+                composeExt.kotlinCompilerPlugin.orNull
+            }
         }
     }
 
@@ -52,6 +57,7 @@ class ComposeCompilerKotlinSupportPlugin : KotlinCompilerPluginSupportPlugin {
 
     override fun applyToCompilation(kotlinCompilation: KotlinCompilation<*>): Provider<List<SubpluginOption>> {
         val target = kotlinCompilation.target
+        composeCompilerArtifactProvider.checkTargetSupported(target)
         return target.project.provider {
             platformPluginOptions[target.platformType] ?: emptyList()
         }

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

@@ -5,33 +5,69 @@
 
 package org.jetbrains.compose.internal
 
-import org.jetbrains.compose.ComposeBuildConfig
+import org.jetbrains.compose.ComposeCompilerCompatability
+import org.jetbrains.kotlin.gradle.plugin.KotlinPlatformType
+import org.jetbrains.kotlin.gradle.plugin.KotlinTarget
 import org.jetbrains.kotlin.gradle.plugin.SubpluginArtifact
 
-internal class ComposeCompilerArtifactProvider(private val customPluginString: () -> String?) {
+private const val KOTLIN_COMPATABILITY_LINK =
+    "https://github.com/JetBrains/compose-jb/blob/master/VERSIONING.md#kotlin-compatibility"
+
+internal class ComposeCompilerArtifactProvider(
+    private val kotlinVersion: String,
+    customPluginString: () -> String?
+) {
+    fun checkTargetSupported(target: KotlinTarget) {
+        if (target.platformType == KotlinPlatformType.js) {
+            require(isJsSupported) {
+                "This version of Compose Multiplatform doesn't support Kotlin " +
+                    "$kotlinVersion for ${target.platformType} target. " +
+                    "Please see $KOTLIN_COMPATABILITY_LINK " +
+                    "to know the latest supported version of Kotlin."
+            }
+        }
+    }
+
+    private var isJsSupported = true
+
     val compilerArtifact: SubpluginArtifact
-        get() {
-            val customPlugin = customPluginString()
-            val customCoordinates = customPlugin?.split(":")
-            return when (customCoordinates?.size) {
-                null -> DefaultCompiler.pluginArtifact
-                1 -> {
-                    val customVersion = customCoordinates[0]
-                    check(customVersion.isNotBlank()) { "'compose.kotlinCompilerPlugin' cannot be blank!" }
-                    DefaultCompiler.pluginArtifact.copy(version = customVersion)
+
+    init {
+        val customPlugin = customPluginString()
+        val customCoordinates = customPlugin?.split(":")
+        when (customCoordinates?.size) {
+            null -> {
+                val version = requireNotNull(
+                    ComposeCompilerCompatability.compilerVersionFor(kotlinVersion)
+                ) {
+                    "This version of Compose Multiplatform doesn't support Kotlin " +
+                        "$kotlinVersion. " +
+                        "Please see $KOTLIN_COMPATABILITY_LINK " +
+                        "to know the latest supported version of Kotlin."
                 }
-                3 -> DefaultCompiler.pluginArtifact.copy(
-                    groupId = customCoordinates[0],
-                    artifactId = customCoordinates[1],
-                    version = customCoordinates[2]
+
+                compilerArtifact = DefaultCompiler.pluginArtifact(
+                    version = version.version
                 )
-                else -> error("""
+                isJsSupported = version.isJsSupported
+            }
+            1 -> {
+                val customVersion = customCoordinates[0]
+                check(customVersion.isNotBlank()) { "'compose.kotlinCompilerPlugin' cannot be blank!" }
+                compilerArtifact = DefaultCompiler.pluginArtifact(version = customVersion)
+            }
+            3 -> compilerArtifact = DefaultCompiler.pluginArtifact(
+                version = customCoordinates[2],
+                groupId = customCoordinates[0],
+                artifactId = customCoordinates[1],
+            )
+            else -> error("""
                         Illegal format of 'compose.kotlinCompilerPlugin' property.
                         Expected format: either '<VERSION>' or '<GROUP_ID>:<ARTIFACT_ID>:<VERSION>'
                         Actual value: '$customPlugin'
                 """.trimIndent())
-            }
         }
+    }
 
     val compilerHostedArtifact: SubpluginArtifact
         get() = compilerArtifact.run {
@@ -47,10 +83,13 @@ internal class ComposeCompilerArtifactProvider(private val customPluginString: (
         const val GROUP_ID = "org.jetbrains.compose.compiler"
         const val ARTIFACT_ID = "compiler"
         const val HOSTED_ARTIFACT_ID = "compiler-hosted"
-        const val VERSION = ComposeBuildConfig.composeCompilerVersion
 
-        val pluginArtifact: SubpluginArtifact
-            get() = SubpluginArtifact(groupId = GROUP_ID, artifactId = ARTIFACT_ID, version = VERSION)
+        fun pluginArtifact(
+            version: String,
+            groupId: String = GROUP_ID,
+            artifactId: String = ARTIFACT_ID,
+        ): SubpluginArtifact =
+            SubpluginArtifact(groupId = groupId, artifactId = artifactId, version = version)
     }
 }
 

gradle-plugins/compose/src/test/kotlin/org/jetbrains/compose/test/tests/integration/GradlePluginTest.kt

@@ -22,7 +22,14 @@ import org.junit.jupiter.api.Test
 class GradlePluginTest : GradlePluginTestBase() {
     @Test
     fun jsMppIsNotBroken() =
-        with(testProject(TestProjects.jsMpp)) {
+        with(
+            testProject(
+                TestProjects.jsMpp,
+                testEnvironment = defaultTestEnvironment.copy(
+                    kotlinVersion = TestProperties.composeJsCompilerCompatibleKotlinVersion
+                )
+            )
+        ) {
             gradle(":compileKotlinJs").build().checks { check ->
                 check.taskOutcome(":compileKotlinJs", TaskOutcome.SUCCESS)
             }

gradle-plugins/compose/src/test/kotlin/org/jetbrains/compose/test/tests/integration/KotlinCompatabilityTest.kt

@@ -0,0 +1,56 @@
+/*
+ * Copyright 2020-2022 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.test.tests.integration
+
+import org.gradle.testkit.runner.TaskOutcome
+import org.gradle.testkit.runner.UnexpectedBuildFailure
+import org.jetbrains.compose.test.utils.GradlePluginTestBase
+import org.jetbrains.compose.test.utils.TestProjects
+import org.jetbrains.compose.test.utils.checks
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertThrows
+
+class KotlinCompatabilityTest : GradlePluginTestBase() {
+    @Test
+    fun testKotlinMpp_1_7_10() = testMpp("1.7.10")
+
+    @Test
+    fun testKotlinJsMpp_1_7_10() = testJsMpp("1.7.10")
+
+    @Test
+    fun testKotlinMpp_1_7_20() = testMpp("1.7.20")
+
+    @Test
+    fun testKotlinJsMpp_1_7_20() {
+        assertThrows<UnexpectedBuildFailure> {
+            testJsMpp("1.7.20")
+        }
+    }
+
+    private fun testMpp(kotlinVersion: String) = with(
+        testProject(
+            TestProjects.mpp,
+            testEnvironment = defaultTestEnvironment.copy(kotlinVersion = kotlinVersion)
+        )
+    ) {
+        val logLine = "Kotlin MPP app is running!"
+        gradle("run").build().checks { check ->
+            check.taskOutcome(":run", TaskOutcome.SUCCESS)
+            check.logContains(logLine)
+        }
+    }
+
+    private fun testJsMpp(kotlinVersion: String) = with(
+        testProject(
+            TestProjects.jsMpp,
+            testEnvironment = defaultTestEnvironment.copy(kotlinVersion = kotlinVersion)
+        )
+    ) {
+        gradle(":compileKotlinJs").build().checks { check ->
+            check.taskOutcome(":compileKotlinJs", TaskOutcome.SUCCESS)
+        }
+    }
+}

gradle-plugins/compose/src/test/kotlin/org/jetbrains/compose/test/tests/unit/ComposeCompilerArtifactProviderTest.kt

@@ -18,31 +18,34 @@ internal class ComposeCompilerArtifactProviderTest {
     fun defaultCompilerArtifact() {
         assertArtifactEquals(
             Expected.jbCompiler,
-            Actual.compiler(null)
+            Actual.compiler(null, TestProperties.composeCompilerCompatibleKotlinVersion)
         )
     }
 
     @Test
     fun defaultCompilerHostedArtifact() {
         assertArtifactEquals(
             Expected.jbCompilerHosted,
-            Actual.compilerHosted(null)
+            Actual.compilerHosted(null, TestProperties.composeCompilerCompatibleKotlinVersion)
         )
     }
 
     @Test
     fun customVersion() {
         assertArtifactEquals(
             Expected.jbCompiler.copy(version = "10.20.30"),
-            Actual.compiler("10.20.30")
+            Actual.compiler("10.20.30", TestProperties.composeCompilerCompatibleKotlinVersion)
         )
     }
 
     @Test
     fun customCompiler() {
         assertArtifactEquals(
             Expected.googleCompiler.copy(version = "1.3.1"),
-            Actual.compiler("androidx.compose.compiler:compiler:1.3.1")
+            Actual.compiler(
+                "androidx.compose.compiler:compiler:1.3.1",
+                TestProperties.androidxCompilerCompatibleKotlinVersion
+            )
         )
     }
 
@@ -51,7 +54,10 @@ internal class ComposeCompilerArtifactProviderTest {
         // check that we don't replace artifactId for non-jb compiler
         assertArtifactEquals(
             Expected.googleCompiler.copy(version = "1.3.1"),
-            Actual.compilerHosted("androidx.compose.compiler:compiler:1.3.1")
+            Actual.compilerHosted(
+                "androidx.compose.compiler:compiler:1.3.1",
+                TestProperties.composeCompilerCompatibleKotlinVersion
+            )
         )
     }
 
@@ -64,7 +70,7 @@ internal class ComposeCompilerArtifactProviderTest {
 
     private fun testIllegalCompiler(pluginString: String?) {
         try {
-            Actual.compiler(pluginString)
+            Actual.compiler(pluginString, "")
         } catch (e: Exception) {
             return
         }
@@ -73,11 +79,11 @@ internal class ComposeCompilerArtifactProviderTest {
     }
 
     object Actual {
-        fun compiler(pluginString: String?) =
-            ComposeCompilerArtifactProvider { pluginString }.compilerArtifact
+        fun compiler(pluginString: String?, kotlinVersion: String) =
+            ComposeCompilerArtifactProvider(kotlinVersion) { pluginString }.compilerArtifact
 
-        fun compilerHosted(pluginString: String?) =
-            ComposeCompilerArtifactProvider { pluginString }.compilerHostedArtifact
+        fun compilerHosted(pluginString: String?, kotlinVersion: String) =
+            ComposeCompilerArtifactProvider(kotlinVersion) { pluginString }.compilerHostedArtifact
     }
 
     object Expected {

gradle-plugins/compose/src/test/kotlin/org/jetbrains/compose/test/utils/GradlePluginTestBase.kt

@@ -17,7 +17,7 @@ abstract class GradlePluginTestBase {
 
     val defaultAndroidxCompilerEnvironment: TestEnvironment
         get() = defaultTestEnvironment.copy(
-            kotlinVersion = TestKotlinVersion.AndroidxCompatible,
+            kotlinVersion = TestKotlinVersions.AndroidxCompatible,
             composeCompilerArtifact = "androidx.compose.compiler:compiler:${TestProperties.androidxCompilerVersion}"
         )