Alternative solution how to add compiler plugin dependency to the project

atomicfu-gradle-plugin/build.gradle

@@ -24,76 +24,15 @@ dependencies {
     // Atomicfu compiler plugin dependency will be loaded to kotlinCompilerPluginClasspath
     // Atomicfu plugin will only be applied if the flag is set kotlinx.atomicfu.enableJsIrTransformation=true
     compileOnly "org.jetbrains.kotlin:atomicfu:$kotlin_version"
+    // This runtimeOnly dependency is added as a temporary WA for the problem #384.
+    // The version 1.6.21 was chosen as the lowest valid version of this artifact, 
+    // and it's expected to be resolved to the highest existing version from the user's classpath.
+    runtimeOnly "org.jetbrains.kotlin:atomicfu:1.6.21"
 
     testImplementation gradleTestKit()
     testImplementation 'org.jetbrains.kotlin:kotlin-test'
     testImplementation 'org.jetbrains.kotlin:kotlin-test-junit'
     testImplementation 'junit:junit:4.12'
 }
 
-configurations {
-    testPluginClasspath {
-        attributes {
-            attribute(
-                    Usage.USAGE_ATTRIBUTE,
-                    project.objects.named(Usage.class, Usage.JAVA_RUNTIME)
-            )
-            attribute(
-                    Category.CATEGORY_ATTRIBUTE,
-                    project.objects.named(Category.class, Category.LIBRARY)
-            )
-        }
-    }
-}
-
-dependencies {
-    testPluginClasspath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
-}
-
 evaluationDependsOn(':atomicfu')
-def atomicfu = project(':atomicfu')
-def atomicfuJvmJarTask = atomicfu.tasks.getByName(atomicfu.kotlin.targets.jvm.artifactsTaskName)
-
-def jsLegacy = atomicfu.kotlin.targets.hasProperty("jsLegacy")
-        ? atomicfu.kotlin.targets.jsLegacy
-        : atomicfu.kotlin.targets.js
-def atomicfuJsJarTask = atomicfu.tasks.getByName(jsLegacy.artifactsTaskName)
-
-def atomicfuMetadataOutput = atomicfu.kotlin.targets.metadata.compilations["main"].output.allOutputs
-
-// Write the plugin's classpath to a file to share with the tests
-task createClasspathManifest {
-    dependsOn(atomicfuJvmJarTask)
-    dependsOn(atomicfuJsJarTask)
-    dependsOn(atomicfuMetadataOutput)
-
-    def outputDir = file("$buildDir/$name")
-    outputs.dir outputDir
-
-    doLast {
-        outputDir.mkdirs()
-        file("$outputDir/plugin-classpath.txt").text = (sourceSets.main.runtimeClasspath + configurations.testPluginClasspath).join("\n")
-        file("$outputDir/atomicfu-jvm.txt").text = atomicfuJvmJarTask.archivePath
-        file("$outputDir/atomicfu-js.txt").text = atomicfuJsJarTask.archivePath
-        file("$outputDir/atomicfu-metadata.txt").text = atomicfuMetadataOutput.join("\n")
-    }
-}
-
-task createKotlinRepoUrlResource {
-    def customKotlinRepoUrl = KotlinConfiguration.getCustomKotlinRepositoryURL(project)
-    if (customKotlinRepoUrl == null) return
-
-    def outputDir = file("$buildDir/$name")
-    outputs.dir outputDir
-
-    doLast {
-        outputDir.mkdirs()
-        file("$outputDir/kotlin-repo-url.txt").text = customKotlinRepoUrl
-    }
-}
-
-// Add the classpath file to the test runtime classpath
-dependencies {
-    testRuntimeOnly files(createClasspathManifest)
-    testRuntimeOnly files(createKotlinRepoUrlResource)
-}

atomicfu-gradle-plugin/src/main/kotlin/kotlinx/atomicfu/plugin/gradle/AtomicFUGradlePlugin.kt

@@ -45,42 +45,12 @@ open class AtomicFUGradlePlugin : Plugin<Project> {
         val pluginVersion = rootProject.buildscript.configurations.findByName("classpath")
             ?.allDependencies?.find { it.name == "atomicfu-gradle-plugin" }?.version
         extensions.add(EXTENSION_NAME, AtomicFUPluginExtension(pluginVersion))
-        checkClasspathForAtomicfuCompilerPlugin(pluginVersion)
         applyAtomicfuCompilerPlugin()
         configureDependencies()
         configureTasks()
     }
 }
 
-private fun Project.checkClasspathForAtomicfuCompilerPlugin(pluginVersion: String?) {
-    val kotlinVersion = getKotlinPluginVersion()
-    rootProject.buildscript.configurations.findByName("classpath")
-        ?.allDependencies?.find { it.group == "org.jetbrains.kotlin" && it.name == "atomicfu" }?.let { 
-            require(it.version == kotlinVersion) {
-                "Please ensure that the Kotlin version specified for the atomicfu compiler plugin matches the Kotlin version used in your project. \n" +
-                "You should use this dependency in your classpath: classpath(\"org.jetbrains.kotlin:atomicfu:$kotlinVersion\")\n\n" +
-                "For details about plugin application, please refer to the README section at: https://github.com/Kotlin/kotlinx-atomicfu/blob/master/README.md#apply-plugin"
-            }
-        }
-        ?: error("Please add a dependency to the atomicfu compiler plugin in the buildscript classpath configuration, " + 
-            "in addition to the atomicfu-gradle-plugin dependency:\n" +
-            "```\n" +    
-            "buildscript {\n" +
-            "    repositories {\n" +
-            "        mavenCentral() \n" +
-            "    }\n" +
-            "\n" +
-            "    dependencies {\n" +
-            "        classpath(\"org.jetbrains.kotlinx:atomicfu-gradle-plugin:$pluginVersion\")\n" +
-            "        classpath(\"org.jetbrains.kotlin:atomicfu:$kotlinVersion\")\n" +
-            "    }\n" +
-            "}\n\n" + 
-            "apply(plugin = \"kotlinx-atomicfu\")\n" +
-            "```\n\n" +
-            "For details about plugin application, please refer to the README section at: https://github.com/Kotlin/kotlinx-atomicfu/blob/master/README.md#apply-plugin"            
-        )
-}
-
 private fun Project.checkCompatibility() {
     val currentGradleVersion = GradleVersion.current()
     val kotlinVersion = getKotlinVersion()

atomicfu/build.gradle

@@ -50,7 +50,11 @@ kotlin {
     sourceSets {
         commonMain {
             dependencies {
-                compileOnly 'org.jetbrains.kotlin:kotlin-stdlib'
+                implementation('org.jetbrains.kotlin:kotlin-stdlib') {
+                    version {
+                        prefer "$kotlin_version"
+                    }
+                }
             }
         }
         commonTest {

integration-testing/build.gradle.kts

@@ -64,6 +64,7 @@ val functionalTest by tasks.registering(Test::class) {
     testClassesDirs = sourceSets["functionalTest"].output.classesDirs
     classpath = sourceSets["functionalTest"].runtimeClasspath
 
+    systemProperties["kotlinVersion"] = kotlin_version
     systemProperties["atomicfuVersion"] = atomicfu_snapshot_version
 
     dependsOn(":atomicfu-gradle-plugin:publishToMavenLocal")

integration-testing/examples/jvm-sample/build.gradle.kts

@@ -6,9 +6,7 @@ buildscript {
 
     dependencies {
         val atomicfuVersion = libs.versions.atomicfuVersion.get()
-        val kotlinVersion = libs.versions.kotlinVersion.get()
         classpath("org.jetbrains.kotlinx:atomicfu-gradle-plugin:$atomicfuVersion")
-        classpath("org.jetbrains.kotlin:atomicfu:$kotlinVersion")
     }
 }
 

integration-testing/examples/mpp-sample/build.gradle.kts

@@ -12,9 +12,7 @@ buildscript {
 
     dependencies {
         val atomicfuVersion = libs.versions.atomicfuVersion.get()
-        val kotlinVersion = libs.versions.kotlinVersion.get()
         classpath("org.jetbrains.kotlinx:atomicfu-gradle-plugin:$atomicfuVersion")
-        classpath("org.jetbrains.kotlin:atomicfu:$kotlinVersion")
     }
 }
 

integration-testing/examples/plugin-order-bug/build.gradle

@@ -0,0 +1,45 @@
+buildscript {
+    repositories {
+        mavenLocal()
+        mavenCentral()
+    }
+
+    dependencies {
+        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:${libs.versions.kotlinVersion.get()}")
+        classpath("org.jetbrains.kotlinx:atomicfu-gradle-plugin:${libs.versions.atomicfuVersion.get()}")
+    }
+}
+// Apply KGP via buildscript to check this issue: #384
+apply plugin: 'org.jetbrains.kotlin.multiplatform'
+apply plugin: 'kotlinx-atomicfu'
+
+repositories {
+    mavenCentral()
+    maven{ url = "https://maven.pkg.jetbrains.space/kotlin/p/kotlin/dev" }
+    mavenLocal()
+}
+
+kotlin {
+    jvm()
+
+    js()
+
+    wasmJs {}
+    wasmWasi {}
+
+    macosArm64()
+    macosX64()
+    linuxArm64()
+    linuxX64()
+    mingwX64()
+
+    sourceSets {
+        commonMain {
+            dependencies {
+                implementation(kotlin("stdlib"))
+                implementation(kotlin("test-junit"))
+            }
+        }
+        commonTest {}
+    }
+}

integration-testing/examples/plugin-order-bug/gradle.properties

@@ -0,0 +1,5 @@
+##
+## Copyright 2016-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+##
+kotlin_version=1.9.20
+atomicfu_version=0.23.1-SNAPSHOT

integration-testing/examples/plugin-order-bug/settings.gradle.kts

@@ -0,0 +1,19 @@
+pluginManagement {
+    repositories {
+        mavenLocal()
+        mavenCentral()
+        maven("https://maven.pkg.jetbrains.space/kotlin/p/kotlin/dev")
+        gradlePluginPortal()
+    }
+}
+
+dependencyResolutionManagement {
+    versionCatalogs {
+        create("libs") {
+            version("atomicfuVersion", providers.gradleProperty("atomicfu_version").orNull)
+            version("kotlinVersion", providers.gradleProperty("kotlin_version").orNull)
+        }
+    }
+}
+
+rootProject.name = "plugin-order-bug"

integration-testing/examples/plugin-order-bug/src/commonMain/kotlin/AtomicSampleClass.kt

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2016-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package examples.mpp_sample
+
+import kotlinx.atomicfu.*
+import kotlinx.atomicfu.locks.*
+import kotlin.test.*
+
+public class AtomicSampleClass {
+    private val _x = atomic(0)
+    val x get() = _x.value
+
+    public fun doWork(finalValue: Int) {
+        assertEquals(0, x)
+        assertEquals(0, _x.getAndSet(3))
+        assertEquals(3, x)
+        assertTrue(_x.compareAndSet(3, finalValue))
+    }
+
+    private val lock = reentrantLock()
+
+    public fun synchronizedFoo(value: Int): Int {
+        return lock.withLock { value }
+    }
+}

integration-testing/examples/plugin-order-bug/src/commonTest/kotlin/AtomicSampleTest.kt

@@ -0,0 +1,17 @@
+/*
+ * Copyright 2016-2023 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+import kotlin.test.*
+import examples.mpp_sample.*
+
+class AtomicSampleTest {
+
+    @Test
+    fun testInt() {
+        val a = AtomicSampleClass()
+        a.doWork(1234)
+        assertEquals(1234, a.x)
+        assertEquals(42, a.synchronizedFoo(42))
+    }
+}

integration-testing/src/functionalTest/kotlin/kotlinx.atomicfu.gradle.plugin.test/cases/PluginOrderBugTest.kt

@@ -0,0 +1,46 @@
+package kotlinx.atomicfu.gradle.plugin.test.cases
+
+import kotlinx.atomicfu.gradle.plugin.test.framework.checker.getProjectClasspath
+import kotlinx.atomicfu.gradle.plugin.test.framework.runner.*
+import kotlinx.atomicfu.gradle.plugin.test.framework.runner.GradleBuild
+import kotlinx.atomicfu.gradle.plugin.test.framework.runner.cleanAndBuild
+import kotlinx.atomicfu.gradle.plugin.test.framework.runner.createGradleBuildFromSources
+import kotlin.test.*
+
+/**
+ * This test reproduces and tracks the issue #384.
+ */
+class PluginOrderBugTest {
+    private val pluginOrderBugProject: GradleBuild = createGradleBuildFromSources("plugin-order-bug")
+
+    @Test
+    fun testUserProjectBuild() {
+        val buildResult = pluginOrderBugProject.cleanAndBuild()
+        assertTrue(buildResult.isSuccessful, buildResult.output)
+    }
+
+    /**
+     * Ensures that the version of atomicfu compiler plugin in the project's classpath equals the version of KGP used in the project.
+     */
+    @Test
+    fun testResolvedCompilerPluginDependency() {
+        val classpath = pluginOrderBugProject.getProjectClasspath()
+        assertTrue(classpath.contains("org.jetbrains.kotlin:atomicfu:${pluginOrderBugProject.getKotlinVersion()}"))
+    }
+
+    /**
+     * kotlin-stdlib is an implementation dependency of :atomicfu module, 
+     * because compileOnly dependencies are not applicable for Native targets (#376).
+     * 
+     * This test ensures that kotlin-stdlib of the Kotlin version used to build kotlinx-atomicfu library is not "required" in the user's project.
+     * The user project should use kotlin-stdlib version that is present in it's classpath.
+     */
+    @Test
+    fun testTransitiveKotlinStdlibDependency() {
+        val dependencies = pluginOrderBugProject.dependencies()
+        assertFalse(dependencies.output.contains("org.jetbrains.kotlin:kotlin-stdlib:{strictly $libraryKotlinVersion}"), 
+            "Strict requirement for 'org.jetbrains.kotlin:kotlin-stdlib:{strictly $libraryKotlinVersion}' was found in the project ${pluginOrderBugProject.projectName} dependencies, " +
+                    "while Kotlin version used in the project is ${pluginOrderBugProject.getKotlinVersion()}"
+        )
+    }
+}

integration-testing/src/functionalTest/kotlin/kotlinx.atomicfu.gradle.plugin.test/framework/checker/DependenciesChecker.kt

@@ -92,3 +92,6 @@ internal fun GradleBuild.checkConsumableDependencies() {
         index++
     }
 }
+
+internal fun GradleBuild.getProjectClasspath(): List<String> =
+    buildEnvironment().getDependenciesForConfig("classpath")

integration-testing/src/functionalTest/kotlin/kotlinx.atomicfu.gradle.plugin.test/framework/runner/BuildRunner.kt

@@ -27,10 +27,7 @@ internal class GradleBuild(val projectName: String, val targetDir: File) {
 
     private var runCount = 0
 
-    fun runGradle(commands: List<String>): BuildResult =
-        buildGradleByShell(runCount++, commands, properties).also {
-            require(it.isSuccessful) { "Running $commands on project $projectName FAILED with error:\n" + it.output }
-        }
+    fun runGradle(commands: List<String>): BuildResult = buildGradleByShell(runCount++, commands, properties)
 }
 
 internal class BuildResult(exitCode: Int, private val logFile: File) {

integration-testing/src/functionalTest/kotlin/kotlinx.atomicfu.gradle.plugin.test/framework/runner/Commands.kt

@@ -4,9 +4,28 @@
 
 package kotlinx.atomicfu.gradle.plugin.test.framework.runner
 
+import kotlinx.atomicfu.gradle.plugin.test.framework.checker.getProjectClasspath
+
 internal fun GradleBuild.cleanAndBuild(): BuildResult = runGradle(listOf("clean", "build"))
 
-internal fun GradleBuild.dependencies(): BuildResult = runGradle(listOf("dependencies"))
+internal fun GradleBuild.dependencies(): BuildResult = 
+    runGradle(listOf("dependencies")).also { 
+        require(it.isSuccessful) { "${this.projectName}:dependencies task FAILED: ${it.output} " }
+    }
+
+internal fun GradleBuild.buildEnvironment(): BuildResult =
+    runGradle(listOf("buildEnvironment")).also {
+        require(it.isSuccessful) { "${this.projectName}:buildEnvironment task FAILED: ${it.output} " }
+    }
 
 internal fun GradleBuild.publishToLocalRepository(): BuildResult =
-    runGradle(listOf("clean", "publish"))
+    runGradle(listOf("clean", "publish")).also {
+        require(it.isSuccessful) { "${this.projectName}:publish task FAILED: ${it.output} " }
+    }
+
+internal fun GradleBuild.getKotlinVersion(): String {
+    val classpath = getProjectClasspath()
+    val kpg = classpath.firstOrNull { it.startsWith("org.jetbrains.kotlin:kotlin-gradle-plugin") }
+        ?: error("kotlin-gradle-plugin is not found in the classpath of the project $projectName")
+    return kpg.substringAfterLast(":")
+}

integration-testing/src/functionalTest/kotlin/kotlinx.atomicfu.gradle.plugin.test/framework/runner/Environment.kt

@@ -13,6 +13,7 @@ internal const val LOCAL_REPOSITORY_URL_PROPERTY = "localRepositoryUrl"
 internal const val DUMMY_VERSION = "DUMMY_VERSION"
 internal const val LOCAL_REPO_DIR_PREFIX = "build/.m2/"
 
+internal val libraryKotlinVersion = System.getProperty("kotlinVersion")
 internal val atomicfuVersion = System.getProperty("atomicfuVersion")
 
 internal val gradleWrapperDir = File("..")