Perform a major cleanup of Gradle scripts after the translation

* Remove the workarounds for IDEA import from gradle.kts
  Without the workarounds, everything still seems to be working
  fine, even after invalidating the caches.
* Clarify the opt-ins.
  Unify the handling of all opt-ins in the project, and also
  add opt-ins for Native that would be widespread otherwise.
  Unfortunately, even after that, the IDE still complains about
  not having the right opt-in in
  kotlinx-coroutines-test/common/test/Helpers.kt.
* Extract the logic of grouping several source sets into a
  single shared one.
* Update the kotlinx-coroutines-core build script:
  - Utilize the multiplatform hierarchy to avoid defining
    extra source sets.
  - Reorder the code for readability.
* Fix the IDE failing to find `actual` implementations for jvmCore
  by making sure `jvmCoreMain` is only defined when the IDE is not
  active. Without a dependency from jvmCoreMain to jvmMain,
  `expect` declarations in the IDE complained that they couldn't
  find `actual` in the `jvmCore` source-set. For example, this
  could be seen in
  kotlinx-coroutines-core/common/src/internal/Concurrent.common.kt.
* Fix passing the stressTest system property to tests
  Broken in #3966
* kotlinOptions -> compilerOptions

Author: dkhalanskyjb

build.gradle.kts

@@ -1,7 +1,6 @@
 import org.jetbrains.kotlin.config.KotlinCompilerVersion
 import org.jetbrains.kotlin.gradle.dsl.*
 import org.gradle.kotlin.dsl.*
-import org.jetbrains.kotlin.konan.target.HostManager
 
 buildscript {
     if (shouldUseLocalMaven(rootProject)) {
@@ -40,8 +39,6 @@ buildscript {
 apply(plugin = "configure-compilation-conventions")
 
 allprojects {
-    // the only place where HostManager could be instantiated
-    project.ext["hostManager"] = HostManager()
     val deployVersion = properties["DeployVersion"]
     if (deployVersion != null) version = deployVersion
 

buildSrc/src/main/kotlin/OptInPreset.kt

@@ -1,4 +1,6 @@
+import org.gradle.api.*
 import org.jetbrains.kotlin.gradle.plugin.*
+import org.gradle.kotlin.dsl.*
 
 fun KotlinSourceSet.configureDirectoryPaths() {
     if (project.isMultiplatform) {
@@ -25,3 +27,30 @@ fun KotlinSourceSet.configureDirectoryPaths() {
         throw IllegalArgumentException("Unclear how to configure source sets for ${project.name}")
     }
 }
+
+/**
+ * Creates shared source sets for a group of source sets.
+ *
+ * [reverseDependencies] is a list of prefixes of names of source sets that depend on the new source set.
+ * [dependencies] is a list of prefixes of names of source sets that the new source set depends on.
+ * [groupName] is the prefix of the names of the new source sets.
+ *
+ * The suffixes of the source sets are "Main" and "Test".
+ */
+fun NamedDomainObjectContainer<KotlinSourceSet>.groupSourceSets(
+    groupName: String,
+    reverseDependencies: List<String>,
+    dependencies: List<String>
+) {
+    val sourceSetSuffixes = listOf("Main", "Test")
+    for (suffix in sourceSetSuffixes) {
+        register(groupName + suffix) {
+            for (dep in dependencies) {
+                dependsOn(get(dep + suffix))
+            }
+            for (revDep in reverseDependencies) {
+                get(revDep + suffix).dependsOn(this)
+            }
+        }
+    }
+}

buildSrc/src/main/kotlin/SourceSets.kt

@@ -23,22 +23,33 @@ configure(subprojects) {
                 allWarningsAsErrors = true
                 freeCompilerArgs.add("-Xexplicit-api=strict")
             }
-
-            /*
-             * Coroutines do not interop with Java and these flags provide a significant
-             * (i.e. close to double-digit) reduction in both bytecode and optimized dex size
-             */
-            val bytecodeSizeReductionOptions =
-                if (this@configureEach is KotlinJvmCompile) listOf(
+            /* Coroutines do not interop with Java and these flags provide a significant
+             * (i.e. close to double-digit) reduction in both bytecode and optimized dex size */
+            if (this@configureEach is KotlinJvmCompile) {
+                freeCompilerArgs.addAll(
                     "-Xno-param-assertions",
                     "-Xno-call-assertions",
                     "-Xno-receiver-assertions"
-                ) else emptyList()
-
-            val newOptions = listOf(
-                "-progressive", "-Xexpect-actual-classes"
-            ) + bytecodeSizeReductionOptions + optInAnnotations.map { "-opt-in=$it" }
-            freeCompilerArgs.addAll(newOptions)
+                )
+            }
+            if (this@configureEach is KotlinNativeCompile) {
+                optIn.addAll(
+                    "kotlinx.cinterop.ExperimentalForeignApi",
+                    "kotlinx.cinterop.UnsafeNumber",
+                    "kotlin.experimental.ExperimentalNativeApi",
+                )
+            }
+            freeCompilerArgs.addAll("-progressive", "-Xexpect-actual-classes")
+            optIn.addAll(
+                "kotlin.experimental.ExperimentalTypeInference",
+                "kotlin.ExperimentalMultiplatform",
+                // our own opt-ins that we don't want to bother with in our own code:
+                "kotlinx.coroutines.DelicateCoroutinesApi",
+                "kotlinx.coroutines.ExperimentalCoroutinesApi",
+                "kotlinx.coroutines.ObsoleteCoroutinesApi",
+                "kotlinx.coroutines.InternalCoroutinesApi",
+                "kotlinx.coroutines.FlowPreview"
+            )
         }
 
     }

buildSrc/src/main/kotlin/configure-compilation-conventions.gradle.kts

@@ -88,30 +88,20 @@ kotlin {
             // workaround for #3968 until this is fixed on atomicfu's side
             api("org.jetbrains.kotlinx:atomicfu:0.23.1")
         }
-        val jsAndWasmSharedMain by registering {
-            dependsOn(commonMain.get())
-        }
-        val jsAndWasmSharedTest by registering {
-            dependsOn(commonTest.get())
-        }
-        jsMain {
-            dependsOn(jsAndWasmSharedMain.get())
-        }
+        jsMain { }
         jsTest {
-            dependsOn(jsAndWasmSharedTest.get())
             dependencies {
                 api("org.jetbrains.kotlin:kotlin-test-js:${version("kotlin")}")
             }
         }
         val wasmJsMain by getting {
-            dependsOn(jsAndWasmSharedMain.get())
         }
         val wasmJsTest by getting {
-            dependsOn(jsAndWasmSharedTest.get())
             dependencies {
                 api("org.jetbrains.kotlin:kotlin-test-wasm-js:${version("kotlin")}")
             }
         }
+        groupSourceSets("jsAndWasmShared", listOf("js", "wasmJs"), listOf("common"))
     }
 }
 
@@ -127,9 +117,5 @@ tasks.named("jvmTest", Test::class) {
         showStandardStreams = true
         events = setOf(TestLogEvent.PASSED, TestLogEvent.FAILED)
     }
-
-    val stressTest = project.properties["stressTest"]
-    if (stressTest != null) {
-        systemProperty("stressTest", "stressTest")
-    }
+    project.properties["stressTest"]?.let { systemProperty("stressTest", it) }
 }