Remove deprecated APIs usage and enable warning-as-errors for build scripts (#2925)

Tapchicoma · web-flow · commit 5439653cf1fa · 2025-02-21T11:55:32.000+01:00
* Fix deprecated URL constructor usage in build scripts.

* Enable warnings-as-errors for build scripts

This should force to update build scripts on any new deprecation introduced in the used plugins.

* Fix deprecation waring in teamcity-conventions.gradle.kts

* Suppress deprecation in native-targets-conventions.gradle.kts

* Use proper OptIn annotation in source-sets-conventions.gradle.kts

* Fix deprecation warnings in Java9Modularity.kt

* Suppress deprecation introduced in Kotlin 2.1.20 release.

Should be migrated once this project will start using Kotlin 2.1.20 by default.

* Enable warnings-as-errors for build logic compilation

This should force to update scripts on new deprecation introduced in the plugins.

* Enable warnings-as-errors for integration-tests project build scripts

* Remove deprecated 'kotlin.js.compiler' property

Only IR compiler available now.
diff --git a/bom/build.gradle.kts b/bom/build.gradle.kts
@@ -37,8 +37,11 @@ publishing {
         forEach { pub ->
             pub as DefaultMavenPublication
             pub.unsetModuleDescriptorGenerator()
-            tasks.matching { it.name == "generateMetadataFileFor${pub.name.capitalize()}Publication" }.all {
-                onlyIf { false }
+
+            tasks.configureEach {
+                if (name == "generateMetadataFileFor${pub.name.capitalizeCompat()}Publication") {
+                    onlyIf { false }
+                }
             }
         }
     }
diff --git a/build.gradle.kts b/build.gradle.kts
@@ -4,6 +4,7 @@
 
 import kotlinx.validation.*
 import org.jetbrains.dokka.gradle.*
+import org.jetbrains.kotlin.gradle.plugin.getKotlinPluginVersion
 
 plugins {
     base
@@ -159,10 +160,8 @@ tasks.withType<org.jetbrains.kotlin.gradle.targets.js.npm.tasks.KotlinNpmInstall
     args.add("--ignore-engines")
 }
 
-// == compiler version setup ==
-gradle.taskGraph.whenReady {
-    println("Using Kotlin compiler version: ${org.jetbrains.kotlin.config.KotlinCompilerVersion.VERSION}")
-}
+// == KGP version setup ==
+logger.warn("Project is using Kotlin Gradle plugin version: ${project.getKotlinPluginVersion()}")
 
 // == projects lists and flags ==
 // getters are required because of variable lazy initialization in Gradle
diff --git a/buildSrc/build.gradle.kts b/buildSrc/build.gradle.kts
@@ -37,6 +37,12 @@ repositories {
     mavenLocal()
 }
 
+kotlin {
+    compilerOptions {
+        allWarningsAsErrors = true
+    }
+}
+
 dependencies {
     implementation(libs.gradlePlugin.kotlin)
     implementation(libs.gradlePlugin.kover)
diff --git a/buildSrc/gradle.properties b/buildSrc/gradle.properties
@@ -0,0 +1 @@
+org.gradle.kotlin.dsl.allWarningsAsErrors=true
diff --git a/buildSrc/src/main/kotlin/Java9Modularity.kt b/buildSrc/src/main/kotlin/Java9Modularity.kt
@@ -16,18 +16,23 @@ import org.jetbrains.kotlin.gradle.*
 import org.jetbrains.kotlin.gradle.dsl.*
 import org.jetbrains.kotlin.gradle.plugin.*
 import org.jetbrains.kotlin.gradle.plugin.mpp.*
-import org.jetbrains.kotlin.gradle.plugin.mpp.pm20.util.*
 import org.jetbrains.kotlin.gradle.targets.jvm.*
 import org.jetbrains.kotlin.gradle.tasks.*
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 import org.jetbrains.kotlin.gradle.tasks.KotlinJvmCompile
-import org.jetbrains.kotlin.gradle.utils.*
 import org.jetbrains.kotlin.tooling.core.*
 import java.io.*
 import kotlin.reflect.*
 import kotlin.reflect.full.*
 
 object Java9Modularity {
+    private val KotlinProjectExtension.targets: Iterable<KotlinTarget>
+        get() = when (this) {
+            is KotlinSingleTargetExtension<*> -> listOf(this.target)
+            is KotlinMultiplatformExtension -> targets
+            else -> error("Unexpected 'kotlin' extension $this")
+        }
+
 
     @JvmStatic
     @JvmOverloads
@@ -50,16 +55,19 @@ object Java9Modularity {
             }
 
             target.compilations.forEach { compilation ->
-                val compileKotlinTask = compilation.compileKotlinTask as KotlinCompile
+                @Suppress("UNCHECKED_CAST")
+                val compileKotlinTask = compilation.compileTaskProvider as TaskProvider<KotlinCompile>
                 val defaultSourceSet = compilation.defaultSourceSet
 
                 // derive the names of the source set and compile module task
                 val sourceSetName = defaultSourceSet.name + "Module"
 
                 kotlin.sourceSets.create(sourceSetName) {
                     val sourceFile = this.kotlin.find { it.name == "module-info.java" }
-                    val targetDirectory = compileKotlinTask.destinationDirectory.map {
-                        it.dir("../${it.asFile.name}Module")
+                    val targetDirectory = compileKotlinTask.flatMap { task ->
+                        task.destinationDirectory.map {
+                            it.dir("../${it.asFile.name}Module")
+                        }
                     }
 
                     // only configure the compilation if necessary
@@ -110,7 +118,7 @@ object Java9Modularity {
      * but it currently won't compile to a module-info.class file.
      */
     private fun Project.registerVerifyModuleTask(
-        compileTask: KotlinCompile,
+        compileTask: TaskProvider<KotlinCompile>,
         sourceFile: File
     ): TaskProvider<out KotlinJvmCompile> {
         apply<KotlinApiPlugin>()
@@ -120,28 +128,28 @@ object Java9Modularity {
         val kotlinApiPlugin = plugins.getPlugin(KotlinApiPlugin::class)
         val verifyModuleTask = kotlinApiPlugin.registerKotlinJvmCompileTask(
             verifyModuleTaskName,
-            compileTask.compilerOptions.moduleName.get()
+            compilerOptions = compileTask.get().compilerOptions,
+            explicitApiMode = provider { ExplicitApiMode.Disabled }
         )
         verifyModuleTask {
             group = VERIFICATION_GROUP
             description = "Verify Kotlin sources for JPMS problems"
-            libraries.from(compileTask.libraries)
-            source(compileTask.sources)
-            source(compileTask.javaSources)
+            libraries.from(compileTask.map { it.libraries })
+            source(compileTask.map { it.sources })
+            source(compileTask.map { it.javaSources })
             // part of work-around for https://youtrack.jetbrains.com/issue/KT-60541
-            @Suppress("INVISIBLE_MEMBER")
-            source(compileTask.scriptSources)
+            source(compileTask.map {
+                @Suppress("INVISIBLE_MEMBER")
+                it.scriptSources
+            })
             source(sourceFile)
             destinationDirectory.set(temporaryDir)
-            multiPlatformEnabled.set(compileTask.multiPlatformEnabled)
+            multiPlatformEnabled.set(compileTask.get().multiPlatformEnabled)
             compilerOptions {
                 jvmTarget.set(JvmTarget.JVM_9)
-                // To support LV override when set in aggregate builds
-                languageVersion.set(compileTask.compilerOptions.languageVersion)
                 freeCompilerArgs.addAll(
                     listOf("-Xjdk-release=9",  "-Xsuppress-version-warnings", "-Xexpect-actual-classes")
                 )
-                optIn.addAll(compileTask.compilerOptions.optIn)
             }
             // work-around for https://youtrack.jetbrains.com/issue/KT-60583
             inputs.files(
@@ -162,18 +170,21 @@ object Java9Modularity {
                     .declaredMemberProperties
                     .find { it.name == "ownModuleName" }
                     ?.get(this) as? Property<String>
-                ownModuleNameProp?.set(compileTask.compilerOptions.moduleName)
+                ownModuleNameProp?.set(compileTask.flatMap { it.compilerOptions.moduleName})
             }
 
             val taskKotlinLanguageVersion = compilerOptions.languageVersion.orElse(KotlinVersion.DEFAULT)
             @OptIn(InternalKotlinGradlePluginApi::class)
             if (taskKotlinLanguageVersion.get() < KotlinVersion.KOTLIN_2_0) {
                 // part of work-around for https://youtrack.jetbrains.com/issue/KT-60541
                 @Suppress("INVISIBLE_MEMBER")
-                commonSourceSet.from(compileTask.commonSourceSet)
+                commonSourceSet.from(compileTask.map {
+                    @Suppress("INVISIBLE_MEMBER")
+                    it.commonSourceSet
+                })
             } else {
-                multiplatformStructure.refinesEdges.set(compileTask.multiplatformStructure.refinesEdges)
-                multiplatformStructure.fragments.set(compileTask.multiplatformStructure.fragments)
+                multiplatformStructure.refinesEdges.set(compileTask.flatMap { it.multiplatformStructure.refinesEdges })
+                multiplatformStructure.fragments.set(compileTask.flatMap { it.multiplatformStructure.fragments })
             }
             // part of work-around for https://youtrack.jetbrains.com/issue/KT-60541
             // and work-around for https://youtrack.jetbrains.com/issue/KT-60582
@@ -183,7 +194,7 @@ object Java9Modularity {
     }
 
     private fun Project.registerCompileModuleTask(
-        compileTask: KotlinCompile,
+        compileTask: TaskProvider<KotlinCompile>,
         sourceFile: File,
         targetDirectory: Provider<out Directory>
     ) = tasks.register("${compileTask.name}Module", JavaCompile::class) {
@@ -203,10 +214,12 @@ object Java9Modularity {
 
         options.compilerArgumentProviders.add(object : CommandLineArgumentProvider {
             @get:CompileClasspath
-            val compileClasspath = compileTask.libraries
+            val compileClasspath = objects.fileCollection().from(
+                compileTask.map { it.libraries }
+            )
 
             @get:CompileClasspath
-            val compiledClasses = compileTask.destinationDirectory
+            val compiledClasses = compileTask.flatMap { it.destinationDirectory }
 
             @get:Input
             val moduleName = sourceFile
diff --git a/buildSrc/src/main/kotlin/dokka-conventions.gradle.kts b/buildSrc/src/main/kotlin/dokka-conventions.gradle.kts
@@ -3,7 +3,7 @@
  */
 
 import org.jetbrains.dokka.gradle.*
-import java.net.URL
+import java.net.URI
 
 /*
  * Copyright 2017-2024 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
@@ -71,7 +71,7 @@ tasks.withType<DokkaTaskPartial>().named("dokkaHtmlPartial") {
             sourceLink {
                 localDirectory.set(rootDir)
 
-                remoteUrl.set(URL("https://github.com/Kotlin/kotlinx.serialization/tree/master"))
+                remoteUrl.set(URI("https://github.com/Kotlin/kotlinx.serialization/tree/master").toURL())
                 remoteLineSuffix.set("#L")
             }
         }
diff --git a/buildSrc/src/main/kotlin/native-targets-conventions.gradle.kts b/buildSrc/src/main/kotlin/native-targets-conventions.gradle.kts
@@ -45,6 +45,7 @@ kotlin {
         androidNativeX64()
 
         // Deprecated, but not removed
+        @Suppress("DEPRECATION")
         linuxArm32Hfp()
     }
 
diff --git a/buildSrc/src/main/kotlin/source-sets-conventions.gradle.kts b/buildSrc/src/main/kotlin/source-sets-conventions.gradle.kts
@@ -2,17 +2,10 @@
  * Copyright 2017-2024 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
  */
 
-@file:OptIn(ExperimentalWasmDsl::class)
-
 import org.gradle.kotlin.dsl.*
 import org.jetbrains.kotlin.gradle.*
 import org.jetbrains.kotlin.gradle.dsl.*
-import org.jetbrains.kotlin.gradle.plugin.mpp.*
-import org.jetbrains.kotlin.gradle.targets.js.dsl.ExperimentalWasmDsl
-import org.jetbrains.kotlin.gradle.targets.js.nodejs.NodeJsRootExtension
-import org.jetbrains.kotlin.gradle.targets.native.tasks.*
 import org.jetbrains.kotlin.gradle.tasks.*
-import org.jetbrains.kotlin.gradle.testing.*
 
 plugins {
     kotlin("multiplatform")
@@ -28,6 +21,7 @@ kotlin {
     explicitApi()
 
     jvm {
+        @Suppress("DEPRECATION") // Migrate on Kotlin 2.1.20 update
         withJava()
         @OptIn(ExperimentalKotlinGradlePluginApi::class)
         compilerOptions {
@@ -53,10 +47,12 @@ kotlin {
         }
     }
 
+    @OptIn(ExperimentalWasmDsl::class)
     wasmJs {
         nodejs()
     }
 
+    @OptIn(ExperimentalWasmDsl::class)
     wasmWasi {
         nodejs()
     }
diff --git a/buildSrc/src/main/kotlin/teamcity-conventions.gradle.kts b/buildSrc/src/main/kotlin/teamcity-conventions.gradle.kts
@@ -2,15 +2,15 @@
  * Copyright 2017-2019 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
  */
 
-import org.gradle.kotlin.dsl.*
-
 val teamcitySuffix = findProperty("teamcitySuffix")?.toString()
 if (teamcityInteractionEnabled && hasProperty("teamcity") && !propertyIsTrue("build_snapshot_train")) {
     // Tell teamcity about version number
     val postfix = if (teamcitySuffix == null) "" else " ($teamcitySuffix)"
     println("##teamcity[buildNumber '${project.version}${postfix}']")
 
-    gradle.taskGraph.beforeTask {
-        println("##teamcity[progressMessage 'Gradle: ${path}:${name}']")
+    tasks.configureEach {
+        doFirst {
+            println("##teamcity[progressMessage 'Gradle: ${path}:${name}']")
+        }
     }
 }
diff --git a/buildSrc/src/main/kotlin/utils.kt b/buildSrc/src/main/kotlin/utils.kt
@@ -0,0 +1,9 @@
+import java.util.Locale
+
+/*
+ * Copyright 2017-2025 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+fun String.capitalizeCompat() = replaceFirstChar {
+    if (it.isLowerCase()) it.titlecase(locale = Locale.getDefault()) else it.toString()
+}
diff --git a/formats/json-io/build.gradle.kts b/formats/json-io/build.gradle.kts
@@ -37,7 +37,7 @@ tasks.named<DokkaTaskPartial>("dokkaHtmlPartial") {
     dokkaSourceSets {
         configureEach {
             externalDocumentationLink {
-                url.set(URL("https://kotlin.github.io/kotlinx-io/"))
+                url.set(URI("https://kotlin.github.io/kotlinx-io/").toURL())
             }
         }
     }
diff --git a/formats/json-okio/build.gradle.kts b/formats/json-okio/build.gradle.kts
@@ -38,7 +38,7 @@ tasks.named<DokkaTaskPartial>("dokkaHtmlPartial") {
     dokkaSourceSets {
         configureEach {
             externalDocumentationLink {
-                url.set(URL("https://square.github.io/okio/3.x/okio/"))
+                url.set(URI("https://square.github.io/okio/3.x/okio/").toURL())
                 packageListUrl.set(
                     file("dokka/okio.package.list").toURI().toURL()
                 )
diff --git a/gradle.properties b/gradle.properties
@@ -15,6 +15,7 @@ kover.enabled=true
 
 org.gradle.parallel=true
 org.gradle.caching=true
+org.gradle.kotlin.dsl.allWarningsAsErrors=true
 
 #kotlin.native.jvmArgs=-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=5007
 #kotlin.native.disableCompilerDaemon=true
diff --git a/integration-test/build.gradle.kts b/integration-test/build.gradle.kts
@@ -4,6 +4,8 @@
 import org.jetbrains.kotlin.gradle.targets.js.nodejs.NodeJsRootExtension
 import org.jetbrains.kotlin.gradle.targets.js.npm.tasks.KotlinNpmInstallTask
 import org.jetbrains.kotlin.gradle.plugin.mpp.*
+import org.jetbrains.kotlin.gradle.dsl.JsModuleKind
+import org.jetbrains.kotlin.gradle.ExperimentalWasmDsl
 
 val serialization_version = property("mainLibVersion") as String
 
@@ -33,16 +35,16 @@ kotlin {
     // Switching module kind for JS is required to run tests
     js {
         nodejs {}
-        compilations.matching { it.name == "main" || it.name == "test" }.configureEach {
-            kotlinOptions {
-                sourceMap = true
-                moduleKind = "umd"
-            }
+        compilerOptions {
+            sourceMap = true
+            moduleKind = JsModuleKind.MODULE_UMD
         }
     }
+    @OptIn(ExperimentalWasmDsl::class)
     wasmJs {
         nodejs()
     }
+    @OptIn(ExperimentalWasmDsl::class)
     wasmWasi {
         nodejs()
     }
@@ -127,14 +129,16 @@ kotlin {
 
     targets.all {
         compilations.all {
-            kotlinOptions {
-                freeCompilerArgs += "-Xexpect-actual-classes"
+            compileTaskProvider.configure {
+                compilerOptions.freeCompilerArgs.add("-Xexpect-actual-classes")
             }
         }
-        compilations["main"].kotlinOptions {
-            allWarningsAsErrors = true
-            // Suppress 'K2 kapt is an experimental feature' warning:
-            freeCompilerArgs += "-Xsuppress-version-warnings"
+        compilations["main"].compileTaskProvider.configure {
+            compilerOptions {
+                allWarningsAsErrors = true
+                // Suppress 'K2 kapt is an experimental feature' warning:
+                freeCompilerArgs.add("-Xsuppress-version-warnings")
+            }
         }
     }
 
diff --git a/integration-test/gradle.properties b/integration-test/gradle.properties
@@ -6,7 +6,6 @@ mainKotlinVersion=2.1.0
 mainLibVersion=1.8.0-SNAPSHOT
 
 kotlin.code.style=official
-kotlin.js.compiler=ir
 
 gradle_node_version = 1.2.0
 node_version = 8.9.3
@@ -17,6 +16,8 @@ source_map_support_version = 0.5.3
 
 kapt.use.k2=true
 
+org.gradle.kotlin.dsl.allWarningsAsErrors=true
+
 # Uncommend & insert path to local Native distribution if you want to test with SNAPSHOT compiler
 #kotlin.native.home=
 

Original file line number	Diff line number	Diff line change
`@@ -37,8 +37,11 @@ publishing {`
`37`	`37`	`forEach { pub ->`
`38`	`38`	`pub as DefaultMavenPublication`
`39`	`39`	`pub.unsetModuleDescriptorGenerator()`
`40`		`- tasks.matching { it.name == "generateMetadataFileFor${pub.name.capitalize()}Publication" }.all {`
`41`		`- onlyIf { false }`
	`40`	`+`
	`41`	`+ tasks.configureEach {`
	`42`	`+ if (name == "generateMetadataFileFor${pub.name.capitalizeCompat()}Publication") {`
	`43`	`+ onlyIf { false }`
	`44`	`+ }`
`42`	`45`	`}`
`43`	`46`	`}`
`44`	`47`	`}`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1 @@`
	`1`	`+org.gradle.kotlin.dsl.allWarningsAsErrors=true`
Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,7 @@`
`3`	`3`	`*/`
`4`	`4`
`5`	`5`	`import org.jetbrains.dokka.gradle.*`
`6`		`-import java.net.URL`
	`6`	`+import java.net.URI`
`7`	`7`
`8`	`8`	`/*`
`9`	`9`	`* Copyright 2017-2024 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license.`
`@@ -71,7 +71,7 @@ tasks.withType<DokkaTaskPartial>().named("dokkaHtmlPartial") {`
`71`	`71`	`sourceLink {`
`72`	`72`	`localDirectory.set(rootDir)`
`73`	`73`
`74`		`- remoteUrl.set(URL("https://github.com/Kotlin/kotlinx.serialization/tree/master"))`
	`74`	`+ remoteUrl.set(URI("https://github.com/Kotlin/kotlinx.serialization/tree/master").toURL())`
`75`	`75`	`remoteLineSuffix.set("#L")`
`76`	`76`	`}`
`77`	`77`	`}`
Original file line number	Diff line number	Diff line change
`@@ -45,6 +45,7 @@ kotlin {`
`45`	`45`	`androidNativeX64()`
`46`	`46`
`47`	`47`	`// Deprecated, but not removed`
	`48`	`+ @Suppress("DEPRECATION")`
`48`	`49`	`linuxArm32Hfp()`
`49`	`50`	`}`
`50`	`51`