Use targets hierarchy API

build.gradle.kts

@@ -108,22 +108,15 @@ doctor {
     enableTestCaching = false
 }
 
-allprojects {
+subprojects {
     group = "io.ktor"
     version = configuredVersion
     extra["hostManager"] = HostManager()
 
     setupTrainForSubproject()
 
-    repositories {
-        mavenLocal()
-        mavenCentral()
-        maven(url = "https://maven.pkg.jetbrains.space/public/p/kotlinx-html/maven")
-        maven("https://maven.pkg.jetbrains.space/kotlin/p/kotlinx/dev")
-    }
-
     val nonDefaultProjectStructure: List<String> by rootProject.extra
-    if (nonDefaultProjectStructure.contains(project.name)) return@allprojects
+    if (nonDefaultProjectStructure.contains(project.name)) return@subprojects
 
     apply(plugin = "kotlin-multiplatform")
     apply(plugin = "atomicfu-conventions")
@@ -145,9 +138,7 @@ allprojects {
     if (!skipPublish.contains(project.name)) {
         configurePublication()
     }
-}
 
-subprojects {
     configureCodestyle()
 }
 

buildSrc/build.gradle.kts

@@ -49,6 +49,10 @@ dependencies {
     implementation(libs.logback.classic)
     implementation(libs.tomlj)
     implementation("org.jetbrains.kotlinx:atomicfu-gradle-plugin:${libs.versions.atomicfu.get()}")
+
+    // A hack to make version catalogs accessible from buildSrc sources
+    // https://github.com/gradle/gradle/issues/15383#issuecomment-779893192
+    implementation(files(libs.javaClass.superclass.protectionDomain.codeSource.location))
 }
 
 kotlin {

buildSrc/settings.gradle.kts

@@ -14,7 +14,7 @@ pluginManagement {
 
 dependencyResolutionManagement {
     versionCatalogs {
-        val libs by creating {
+        create("libs") {
             from(files("../gradle/libs.versions.toml"))
         }
     }

buildSrc/src/main/kotlin/CommonConfig.kt

@@ -1,6 +1,8 @@
 /*
- * Copyright 2014-2022 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license.
+ * Copyright 2014-2024 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license.
  */
+
+import internal.*
 import org.gradle.api.*
 import org.gradle.kotlin.dsl.*
 
@@ -9,13 +11,13 @@ fun Project.configureCommon() {
         sourceSets {
             commonMain {
                 dependencies {
-                    api("org.jetbrains.kotlinx:kotlinx-coroutines-core:${Versions.coroutines}")
+                    api(libs.kotlinx.coroutines.core)
                 }
             }
 
             commonTest {
                 dependencies {
-                    implementation(kotlin("test"))
+                    implementation(libs.kotlin.test)
                 }
             }
         }

buildSrc/src/main/kotlin/JsConfig.kt

@@ -1,60 +1,58 @@
 /*
  * Copyright 2014-2024 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license.
  */
-@file:Suppress("UNUSED_VARIABLE")
 
+import internal.*
 import org.gradle.api.*
+import org.gradle.internal.extensions.stdlib.*
 import org.gradle.kotlin.dsl.*
-import org.jetbrains.kotlin.gradle.targets.js.ir.*
+import org.jetbrains.kotlin.gradle.targets.js.dsl.*
 import java.io.*
+import kotlin.toString
 
 fun Project.configureJs() {
-    configureJsTasks()
-
     kotlin {
+        js {
+            if (project.targetIsEnabled("js.nodeJs")) nodejs { useMochaForTests() }
+            if (project.targetIsEnabled("js.browser")) browser { useKarmaForTests() }
+
+            binaries.library()
+        }
+
         sourceSets {
-            val jsTest by getting {
+            jsTest {
                 dependencies {
-                    implementation(npm("puppeteer", Versions.puppeteer))
+                    implementation(npm("puppeteer", libs.versions.puppeteer.get()))
                 }
             }
         }
     }
 
-    configureJsTestTasks()
+    configureJsTestTasks(target = "js")
 }
 
-private fun Project.configureJsTasks() {
-    kotlin {
-        js {
-            if (project.targetIsEnabled("js.nodeJs")) {
-                nodejs {
-                    testTask {
-                        useMocha {
-                            timeout = "10000"
-                        }
-                    }
-                }
-            }
-
-            (this as KotlinJsIrTarget).whenBrowserConfigured {
-                testTask {
-                    useKarma {
-                        useChromeHeadless()
-                        useConfigDirectory(File(project.rootProject.projectDir, "karma"))
-                    }
-                }
-            }
+internal fun KotlinJsSubTargetDsl.useMochaForTests() {
+    testTask {
+        useMocha {
+            timeout = "10000"
+        }
+    }
+}
 
-            binaries.library()
+internal fun KotlinJsSubTargetDsl.useKarmaForTests() {
+    testTask {
+        useKarma {
+            useChromeHeadless()
+            useConfigDirectory(File(project.rootProject.projectDir, "karma"))
         }
     }
 }
 
-private fun Project.configureJsTestTasks() {
+internal fun Project.configureJsTestTasks(target: String) {
     val shouldRunJsBrowserTest = !hasProperty("teamcity") || hasProperty("enable-js-tests")
     if (shouldRunJsBrowserTest) return
 
-    tasks.maybeNamed("cleanJsBrowserTest") { onlyIf { false } }
-    tasks.maybeNamed("jsBrowserTest") { onlyIf { false } }
+    val capitalizedTarget = target.replaceFirstChar { it.titlecase() }
+    tasks.maybeNamed("clean${capitalizedTarget}BrowserTest") { onlyIf { false } }
+    tasks.maybeNamed("${target}BrowserTest") { onlyIf { false } }
 }

buildSrc/src/main/kotlin/JvmConfig.kt

@@ -2,6 +2,7 @@
  * Copyright 2014-2024 JetBrains s.r.o and contributors. Use of this source code is governed by the Apache 2.0 license.
  */
 
+import internal.*
 import org.gradle.api.*
 import org.gradle.api.tasks.testing.*
 import org.gradle.jvm.tasks.*
@@ -15,41 +16,30 @@ fun Project.configureJvm() {
         else -> 8
     }
 
-    val jvm = kotlin.jvm()
+    kotlin {
+        jvm()
 
-    kotlin.sourceSets {
-        val jvmMain by getting {
-            dependencies {
-                if (jdk > 6) {
-                    api("org.jetbrains.kotlin:kotlin-stdlib-jdk7:${Versions.kotlin}")
+        sourceSets {
+            jvmMain {
+                dependencies {
+                    api(libs.slf4j.api)
                 }
-                if (jdk > 7) {
-                    api("org.jetbrains.kotlin:kotlin-stdlib-jdk8:${Versions.kotlin}")
-                    api("org.jetbrains.kotlinx:kotlinx-coroutines-jdk8:${Versions.coroutines}") {
-                        exclude(module = "kotlin-stdlib")
-                        exclude(module = "kotlin-stdlib-jvm")
-                        exclude(module = "kotlin-stdlib-jdk8")
-                        exclude(module = "kotlin-stdlib-jdk7")
-                    }
-                }
-
-                api("org.slf4j:slf4j-api:${Versions.slf4j}")
             }
-        }
 
-        val jvmTest by getting {
-            dependencies {
-                implementation(kotlin("test-junit5"))
-                implementation("org.junit.jupiter:junit-jupiter:${Versions.junit}")
-                implementation("org.jetbrains.kotlinx:kotlinx-coroutines-debug:${Versions.coroutines}")
+            jvmTest {
+                dependencies {
+                    implementation(libs.kotlin.test.junit5)
+                    implementation(libs.junit)
+                    implementation(libs.kotlinx.coroutines.debug)
+                }
             }
         }
     }
 
     tasks.register<Jar>("jarTest") {
         dependsOn(tasks.named("jvmTestClasses"))
         archiveClassifier = "test"
-        from(jvm.compilations.named("test").map { it.output })
+        from(kotlin.jvm().compilations.named("test").map { it.output })
     }
 
     configurations {