Migrate Gradle deprecations (#1745)

build-logic/src/main/kotlin/PklPublishing.kt

@@ -63,58 +63,60 @@ fun Project.configurePklPomMetadata() {
 
 /** Configures POM validation task to check for unresolved versions and snapshots in releases. */
 fun Project.configurePomValidation() {
-  val validatePom by tasks.registering {
-    if (tasks.findByName("generatePomFileForLibraryPublication") == null) {
-      return@registering
-    }
-    val generatePomFileForLibraryPublication by tasks.existing(GenerateMavenPom::class)
-    val outputFile =
-      layout.buildDirectory.file("validatePom") // dummy output to satisfy up-to-date check
+  val validatePom =
+    tasks.register("validatePom") {
+      if (tasks.findByName("generatePomFileForLibraryPublication") == null) {
+        return@register
+      }
+      val generatePomFileForLibraryPublication =
+        tasks.named<GenerateMavenPom>("generatePomFileForLibraryPublication")
+      val outputFile =
+        layout.buildDirectory.file("validatePom") // dummy output to satisfy up-to-date check
 
-    dependsOn(generatePomFileForLibraryPublication)
-    inputs.file(generatePomFileForLibraryPublication.get().destination)
-    outputs.file(outputFile)
+      dependsOn(generatePomFileForLibraryPublication)
+      inputs.file(generatePomFileForLibraryPublication.get().destination)
+      outputs.file(outputFile)
 
-    doLast {
-      outputFile.get().asFile.delete()
+      doLast {
+        outputFile.get().asFile.delete()
 
-      val pomFile = generatePomFileForLibraryPublication.get().destination
-      assert(pomFile.exists())
+        val pomFile = generatePomFileForLibraryPublication.get().destination
+        assert(pomFile.exists())
 
-      val text = pomFile.readText()
+        val text = pomFile.readText()
 
-      run {
-        val unresolvedVersion = Regex("<version>.*[+,()\\[\\]].*</version>")
-        val matches = unresolvedVersion.findAll(text).toList()
-        if (matches.isNotEmpty()) {
-          throw org.gradle.api.GradleException(
-            """
+        run {
+          val unresolvedVersion = Regex("<version>.*[+,()\\[\\]].*</version>")
+          val matches = unresolvedVersion.findAll(text).toList()
+          if (matches.isNotEmpty()) {
+            throw org.gradle.api.GradleException(
+              """
         Found unresolved version selector(s) in generated POM:
         ${matches.joinToString("\n") { it.groupValues[0] }}
       """
-              .trimIndent()
-          )
+                .trimIndent()
+            )
+          }
         }
-      }
 
-      val buildInfo = project.extensions.getByType<BuildInfo>()
-      if (buildInfo.isReleaseBuild) {
-        val snapshotVersion = Regex("<version>.*-SNAPSHOT</version>")
-        val matches = snapshotVersion.findAll(text).toList()
-        if (matches.isNotEmpty()) {
-          throw org.gradle.api.GradleException(
-            """
+        val buildInfo = project.extensions.getByType<BuildInfo>()
+        if (buildInfo.isReleaseBuild) {
+          val snapshotVersion = Regex("<version>.*-SNAPSHOT</version>")
+          val matches = snapshotVersion.findAll(text).toList()
+          if (matches.isNotEmpty()) {
+            throw org.gradle.api.GradleException(
+              """
         Found snapshot version(s) in generated POM of Pkl release version:
         ${matches.joinToString("\n") { it.groupValues[0] }}
       """
-              .trimIndent()
-          )
+                .trimIndent()
+            )
+          }
         }
-      }
 
-      outputFile.get().asFile.writeText("OK")
+        outputFile.get().asFile.writeText("OK")
+      }
     }
-  }
 
   tasks.named("publish") { dependsOn(validatePom) }
 }

build-logic/src/main/kotlin/pklAllProjects.gradle.kts

@@ -79,7 +79,7 @@ plugins.withType(MavenPublishPlugin::class).configureEach {
   }
 }
 
-val allDependencies by tasks.registering(DependencyReportTask::class)
+val allDependencies = tasks.register<DependencyReportTask>("allDependencies")
 
 tasks.withType(Test::class).configureEach {
   System.getProperty("testReportsDir")?.let { reportsDir ->

build-logic/src/main/kotlin/pklFatJar.gradle.kts

@@ -132,8 +132,8 @@ tasks.shadowJar {
 
 shadow { addShadowVariantIntoJavaComponent = false }
 
-val testFatJar by
-  tasks.registering(Test::class) {
+val testFatJar =
+  tasks.register<Test>("testFatJar") {
     testClassesDirs = files(tasks.test.get().testClassesDirs)
     classpath =
       // compiled test classes
@@ -148,47 +148,48 @@ val testFatJar by
 
 tasks.check { dependsOn(testFatJar) }
 
-val validateFatJar by tasks.registering {
-  val outputFile = layout.buildDirectory.file("validateFatJar/result.txt")
-  inputs.files(tasks.shadowJar)
-  inputs.property("nonRelocations", nonRelocations)
-  outputs.file(outputFile)
+val validateFatJar =
+  tasks.register("validateFatJar") {
+    val outputFile = layout.buildDirectory.file("validateFatJar/result.txt")
+    inputs.files(tasks.shadowJar)
+    inputs.property("nonRelocations", nonRelocations)
+    outputs.file(outputFile)
 
-  doLast {
-    val unshadowedFiles = mutableListOf<String>()
-    zipTree(tasks.shadowJar.get().outputs.files.singleFile).visit {
-      val fileDetails = this
-      val path = fileDetails.relativePath.pathString
-      if (
-        !(fileDetails.isDirectory ||
-          path.startsWith("org/pkl/") ||
-          path.startsWith("META-INF/") ||
-          nonRelocations.any { path.startsWith(it) })
-      ) {
-        // don't throw exception inside `visit`
-        // as this gives a misleading "Could not expand ZIP" error message
-        unshadowedFiles.add(path)
+    doLast {
+      val unshadowedFiles = mutableListOf<String>()
+      zipTree(tasks.shadowJar.get().outputs.files.singleFile).visit {
+        val fileDetails = this
+        val path = fileDetails.relativePath.pathString
+        if (
+          !(fileDetails.isDirectory ||
+            path.startsWith("org/pkl/") ||
+            path.startsWith("META-INF/") ||
+            nonRelocations.any { path.startsWith(it) })
+        ) {
+          // don't throw exception inside `visit`
+          // as this gives a misleading "Could not expand ZIP" error message
+          unshadowedFiles.add(path)
+        }
+      }
+      if (unshadowedFiles.isEmpty()) {
+        outputFile.get().asFile.writeText("SUCCESS")
+      } else {
+        outputFile.get().asFile.writeText("FAILURE")
+        throw GradleException("Found unshadowed files:\n" + unshadowedFiles.joinToString("\n"))
       }
     }
-    if (unshadowedFiles.isEmpty()) {
-      outputFile.get().asFile.writeText("SUCCESS")
-    } else {
-      outputFile.get().asFile.writeText("FAILURE")
-      throw GradleException("Found unshadowed files:\n" + unshadowedFiles.joinToString("\n"))
-    }
   }
-}
 
 tasks.check { dependsOn(validateFatJar) }
 
-val resolveSourcesJars by
-  tasks.registering(ResolveSourcesJars::class) {
+val resolveSourcesJars =
+  tasks.register<ResolveSourcesJars>("resolveSourcesJars") {
     configuration.set(configurations.runtimeClasspath)
     outputDir.set(layout.buildDirectory.dir("resolveSourcesJars"))
   }
 
-val fatSourcesJar by
-  tasks.registering(MergeSourcesJars::class) {
+val fatSourcesJar =
+  tasks.register<MergeSourcesJars>("fatSourcesJar") {
     plugins.withId("pklJavaLibrary") { inputJars.from(tasks.named("sourcesJar")) }
     inputJars.from(firstPartySourcesJarsConfiguration)
     inputJars.from(resolveSourcesJars.map { fileTree(it.outputDir) })
@@ -213,7 +214,7 @@ publishing {
       artifact(fatSourcesJar.flatMap { it.outputJar.asFile }) { classifier = "sources" }
 
       plugins.withId("pklJavaLibrary") {
-        val javadocJar by tasks.existing(Jar::class)
+        val javadocJar = tasks.named<Jar>("javadocJar")
         // Javadoc Jar is not fat (didn't invest effort)
         artifact(javadocJar.flatMap { it.archiveFile }) { classifier = "javadoc" }
       }

build-logic/src/main/kotlin/pklGraalVm.gradle.kts

@@ -21,11 +21,15 @@ plugins { id("de.undercouch.download") }
 val buildInfo = project.extensions.getByType<BuildInfo>()
 
 // tries to minimize chance of corruption by download-to-temp-file-and-move
-val downloadGraalVmAarch64 by
-  tasks.registering(Download::class) { configureDownloadGraalVm(buildInfo.graalVmAarch64) }
+val downloadGraalVmAarch64 =
+  tasks.register<Download>("downloadGraalVmAarch64") {
+    configureDownloadGraalVm(buildInfo.graalVmAarch64)
+  }
 
-val downloadGraalVmAmd64 by
-  tasks.registering(Download::class) { configureDownloadGraalVm(buildInfo.graalVmAmd64) }
+val downloadGraalVmAmd64 =
+  tasks.register<Download>("downloadGraalVmAmd64") {
+    configureDownloadGraalVm(buildInfo.graalVmAmd64)
+  }
 
 fun Download.configureDownloadGraalVm(graalvm: BuildInfo.GraalVm) {
   onlyIf { !graalvm.installDir.exists() }
@@ -37,14 +41,14 @@ fun Download.configureDownloadGraalVm(graalvm: BuildInfo.GraalVm) {
   tempAndMove(true)
 }
 
-val verifyGraalVmAarch64 by
-  tasks.registering(Verify::class) {
+val verifyGraalVmAarch64 =
+  tasks.register<Verify>("verifyGraalVmAarch64") {
     configureVerifyGraalVm(buildInfo.graalVmAarch64)
     dependsOn(downloadGraalVmAarch64)
   }
 
-val verifyGraalVmAmd64 by
-  tasks.registering(Verify::class) {
+val verifyGraalVmAmd64 =
+  tasks.register<Verify>("verifyGraalVmAmd64") {
     configureVerifyGraalVm(buildInfo.graalVmAmd64)
     dependsOn(downloadGraalVmAmd64)
   }
@@ -60,15 +64,15 @@ fun Verify.configureVerifyGraalVm(graalvm: BuildInfo.GraalVm) {
 }
 
 @Suppress("unused")
-val installGraalVmAarch64 by
-  tasks.registering(InstallGraalVm::class) {
+val installGraalVmAarch64 =
+  tasks.register<InstallGraalVm>("installGraalVmAarch64") {
     dependsOn(verifyGraalVmAarch64)
     graalVm = buildInfo.graalVmAarch64
   }
 
 @Suppress("unused")
-val installGraalVmAmd64 by
-  tasks.registering(InstallGraalVm::class) {
+val installGraalVmAmd64 =
+  tasks.register<InstallGraalVm>("installGraalVmAmd64") {
     dependsOn(verifyGraalVmAmd64)
     graalVm = buildInfo.graalVmAmd64
   }

build-logic/src/main/kotlin/pklHtmlValidator.gradle.kts

@@ -47,8 +47,8 @@ dependencies {
   }
 }
 
-val validateHtml by
-  tasks.registering(JavaExec::class) {
+val validateHtml =
+  tasks.register<JavaExec>("validateHtml") {
     val resultFile = layout.buildDirectory.file("validateHtml/result.txt")
     inputs.files(htmlValidator.sources)
     outputs.file(resultFile)

build-logic/src/main/kotlin/pklJavaExecutable.gradle.kts

@@ -26,8 +26,8 @@ plugins {
 val executableSpec = project.extensions.create("executable", ExecutableSpec::class.java)
 val buildInfo = project.extensions.getByType<BuildInfo>()
 
-val javaExecutable by
-  tasks.registering(ExecutableJar::class) {
+val javaExecutable =
+  tasks.register<ExecutableJar>("javaExecutable") {
     group = "build"
     dependsOn(tasks.jar)
     inJar = tasks.shadowJar.flatMap { it.archiveFile }
@@ -77,7 +77,8 @@ fun Task.setupTestStartJavaExecutable(launcher: Provider<JavaLauncher>? = null)
   }
 }
 
-val testStartJavaExecutable by tasks.registering { setupTestStartJavaExecutable() }
+val testStartJavaExecutable =
+  tasks.register("testStartJavaExecutable") { setupTestStartJavaExecutable() }
 
 // Setup `testStartJavaExecutable` tasks for multi-JDK testing.
 val testStartJavaExecutableOnOtherJdks =

build-logic/src/main/kotlin/pklNativeExecutable.gradle.kts

@@ -30,22 +30,26 @@ plugins {
 val executableSpec = project.extensions.getByType<ExecutableSpec>()
 val buildInfo = project.extensions.getByType<BuildInfo>()
 
-val stagedMacAmd64Executable: Configuration by configurations.creating
-val stagedMacAarch64Executable: Configuration by configurations.creating
-val stagedLinuxAmd64Executable: Configuration by configurations.creating
-val stagedLinuxAarch64Executable: Configuration by configurations.creating
-val stagedAlpineLinuxAmd64Executable: Configuration by configurations.creating
-val stagedWindowsAmd64Executable: Configuration by configurations.creating
+val stagedMacAmd64Executable: Configuration = configurations.create("stagedMacAmd64Executable")
+val stagedMacAarch64Executable: Configuration = configurations.create("stagedMacAarch64Executable")
+val stagedLinuxAmd64Executable: Configuration = configurations.create("stagedLinuxAmd64Executable")
+val stagedLinuxAarch64Executable: Configuration =
+  configurations.create("stagedLinuxAarch64Executable")
+val stagedAlpineLinuxAmd64Executable: Configuration =
+  configurations.create("stagedAlpineLinuxAmd64Executable")
+val stagedWindowsAmd64Executable: Configuration =
+  configurations.create("stagedWindowsAmd64Executable")
 
-val nativeImageClasspath by configurations.creating {
-  extendsFrom(configurations.runtimeClasspath.get())
-  // Ensure native-image version uses GraalVM C SDKs instead of Java FFI or JNA
-  // (comes from artifact `mordant-jvm-graal-ffi`).
-  exclude("com.github.ajalt.mordant", "mordant-jvm-ffm")
-  exclude("com.github.ajalt.mordant", "mordant-jvm-ffm-jvm")
-  exclude("com.github.ajalt.mordant", "mordant-jvm-jna")
-  exclude("com.github.ajalt.mordant", "mordant-jvm-jna-jvm")
-}
+val nativeImageClasspath =
+  configurations.create("nativeImageClasspath") {
+    extendsFrom(configurations.runtimeClasspath.get())
+    // Ensure native-image version uses GraalVM C SDKs instead of Java FFI or JNA
+    // (comes from artifact `mordant-jvm-graal-ffi`).
+    exclude("com.github.ajalt.mordant", "mordant-jvm-ffm")
+    exclude("com.github.ajalt.mordant", "mordant-jvm-ffm-jvm")
+    exclude("com.github.ajalt.mordant", "mordant-jvm-jna")
+    exclude("com.github.ajalt.mordant", "mordant-jvm-jna-jvm")
+  }
 
 val libs = the<LibrariesForLibs>()
 
@@ -85,32 +89,32 @@ private fun NativeImageBuild.setClasspath() {
   classpath.from(nativeImageClasspath)
 }
 
-val macExecutableAmd64 by
-  tasks.registering(NativeImageBuild::class) {
+val macExecutableAmd64 =
+  tasks.register<NativeImageBuild>("macExecutableAmd64") {
     imageName = executableSpec.name.map { "$it-macos-amd64" }
     mainClass = executableSpec.mainClass
     amd64()
     setClasspath()
   }
 
-val macExecutableAarch64 by
-  tasks.registering(NativeImageBuild::class) {
+val macExecutableAarch64 =
+  tasks.register<NativeImageBuild>("macExecutableAarch64") {
     imageName = executableSpec.name.map { "$it-macos-aarch64" }
     mainClass = executableSpec.mainClass
     aarch64()
     setClasspath()
   }
 
-val linuxExecutableAmd64 by
-  tasks.registering(NativeImageBuild::class) {
+val linuxExecutableAmd64 =
+  tasks.register<NativeImageBuild>("linuxExecutableAmd64") {
     imageName = executableSpec.name.map { "$it-linux-amd64" }
     mainClass = executableSpec.mainClass
     amd64()
     setClasspath()
   }
 
-val linuxExecutableAarch64 by
-  tasks.registering(NativeImageBuild::class) {
+val linuxExecutableAarch64 =
+  tasks.register<NativeImageBuild>("linuxExecutableAarch64") {
     imageName = executableSpec.name.map { "$it-linux-aarch64" }
     mainClass = executableSpec.mainClass
     aarch64()
@@ -120,8 +124,8 @@ val linuxExecutableAarch64 by
     extraNativeImageArgs.add("-H:PageSize=65536")
   }
 
-val alpineExecutableAmd64 by
-  tasks.registering(NativeImageBuild::class) {
+val alpineExecutableAmd64 =
+  tasks.register<NativeImageBuild>("alpineExecutableAmd64") {
     imageName = executableSpec.name.map { "$it-alpine-linux-amd64" }
     mainClass = executableSpec.mainClass
     amd64()
@@ -129,73 +133,75 @@ val alpineExecutableAmd64 by
     extraNativeImageArgs.addAll(listOf("--static", "--libc=musl"))
   }
 
-val windowsExecutableAmd64 by
-  tasks.registering(NativeImageBuild::class) {
+val windowsExecutableAmd64 =
+  tasks.register<NativeImageBuild>("windowsExecutableAmd64") {
     imageName = executableSpec.name.map { "$it-windows-amd64" }
     mainClass = executableSpec.mainClass
     amd64()
     setClasspath()
   }
 
-val assembleNative by tasks.existing
+val assembleNative = tasks.named("assembleNative")
 
-val testStartNativeExecutable by tasks.registering {
-  dependsOn(assembleNative)
+val testStartNativeExecutable =
+  tasks.register("testStartNativeExecutable") {
+    dependsOn(assembleNative)
 
-  // dummy file for up-to-date checking
-  val outputFile = project.layout.buildDirectory.file("testStartNativeExecutable/output.txt")
-  outputs.file(outputFile)
+    // dummy file for up-to-date checking
+    val outputFile = project.layout.buildDirectory.file("testStartNativeExecutable/output.txt")
+    outputs.file(outputFile)
 
-  val execOutput = providers.exec {
-    commandLine(assembleNative.get().outputs.files.singleFile, "--version")
-  }
-
-  doLast {
-    val outputText = execOutput.standardOutput.asText.get()
-    if (!outputText.contains(buildInfo.pklVersionNonUnique)) {
-      throw GradleException(
-        "Expected version output to contain current version (${buildInfo.pklVersionNonUnique}), but got '$outputText'"
-      )
+    val execOutput = providers.exec {
+      commandLine(assembleNative.get().outputs.files.singleFile, "--version")
     }
-    outputFile.get().asFile.toPath().apply {
-      try {
-        parent.createDirectories()
-      } catch (_: java.nio.file.FileAlreadyExistsException) {}
-      writeText("OK")
+
+    doLast {
+      val outputText = execOutput.standardOutput.asText.get()
+      if (!outputText.contains(buildInfo.pklVersionNonUnique)) {
+        throw GradleException(
+          "Expected version output to contain current version (${buildInfo.pklVersionNonUnique}), but got '$outputText'"
+        )
+      }
+      outputFile.get().asFile.toPath().apply {
+        try {
+          parent.createDirectories()
+        } catch (_: java.nio.file.FileAlreadyExistsException) {}
+        writeText("OK")
+      }
     }
   }
-}
 
 val requiredGlibcVersion: Version = Version.parse("2.17")
 
-val checkGlibc by tasks.registering {
-  enabled = buildInfo.os.isLinux && !buildInfo.musl
-  dependsOn(assembleNative)
-  doLast {
-    val exec = providers.exec {
-      commandLine("objdump", "-T", assembleNative.get().outputs.files.singleFile)
-    }
-    val output = exec.standardOutput.asText.get()
-    val minimumGlibcVersion =
-      output
-        .split("\n")
-        .mapNotNull { line ->
-          val match = Regex("GLIBC_([.0-9]*)").find(line)
-          match?.groups[1]?.let { Version.parse(it.value) }
-        }
-        .maxOrNull()
-    if (minimumGlibcVersion == null) {
-      throw GradleException(
-        "Could not determine glibc version from executable. objdump output: $output"
-      )
-    }
-    if (minimumGlibcVersion > requiredGlibcVersion) {
-      throw GradleException(
-        "Incorrect glibc version. Found: $minimumGlibcVersion, required: $requiredGlibcVersion"
-      )
+val checkGlibc =
+  tasks.register("checkGlibc") {
+    enabled = buildInfo.os.isLinux && !buildInfo.musl
+    dependsOn(assembleNative)
+    doLast {
+      val exec = providers.exec {
+        commandLine("objdump", "-T", assembleNative.get().outputs.files.singleFile)
+      }
+      val output = exec.standardOutput.asText.get()
+      val minimumGlibcVersion =
+        output
+          .split("\n")
+          .mapNotNull { line ->
+            val match = Regex("GLIBC_([.0-9]*)").find(line)
+            match?.groups[1]?.let { Version.parse(it.value) }
+          }
+          .maxOrNull()
+      if (minimumGlibcVersion == null) {
+        throw GradleException(
+          "Could not determine glibc version from executable. objdump output: $output"
+        )
+      }
+      if (minimumGlibcVersion > requiredGlibcVersion) {
+        throw GradleException(
+          "Incorrect glibc version. Found: $minimumGlibcVersion, required: $requiredGlibcVersion"
+        )
+      }
     }
   }
-}
 
 // Expose underlying task's outputs
 private fun <T : Task> Task.wraps(other: TaskProvider<T>) {
@@ -203,19 +209,24 @@ private fun <T : Task> Task.wraps(other: TaskProvider<T>) {
   outputs.files(other)
 }
 
-val testNative by tasks.existing { dependsOn(testStartNativeExecutable, checkGlibc) }
+val testNative = tasks.named("testNative") { dependsOn(testStartNativeExecutable, checkGlibc) }
 
-val assembleNativeMacOsAarch64 by tasks.existing { wraps(macExecutableAarch64) }
+val assembleNativeMacOsAarch64 =
+  tasks.named("assembleNativeMacOsAarch64") { wraps(macExecutableAarch64) }
 
-val assembleNativeMacOsAmd64 by tasks.existing { wraps(macExecutableAmd64) }
+val assembleNativeMacOsAmd64 = tasks.named("assembleNativeMacOsAmd64") { wraps(macExecutableAmd64) }
 
-val assembleNativeLinuxAarch64 by tasks.existing { wraps(linuxExecutableAarch64) }
+val assembleNativeLinuxAarch64 =
+  tasks.named("assembleNativeLinuxAarch64") { wraps(linuxExecutableAarch64) }
 
-val assembleNativeLinuxAmd64 by tasks.existing { wraps(linuxExecutableAmd64) }
+val assembleNativeLinuxAmd64 =
+  tasks.named("assembleNativeLinuxAmd64") { wraps(linuxExecutableAmd64) }
 
-val assembleNativeAlpineLinuxAmd64 by tasks.existing { wraps(alpineExecutableAmd64) }
+val assembleNativeAlpineLinuxAmd64 =
+  tasks.named("assembleNativeAlpineLinuxAmd64") { wraps(alpineExecutableAmd64) }
 
-val assembleNativeWindowsAmd64 by tasks.existing { wraps(windowsExecutableAmd64) }
+val assembleNativeWindowsAmd64 =
+  tasks.named("assembleNativeWindowsAmd64") { wraps(windowsExecutableAmd64) }
 
 publishing {
   publications {

build-logic/src/main/kotlin/pklNativeLifecycle.gradle.kts

@@ -13,29 +13,31 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-val assembleNativeMacOsAarch64 by tasks.registering { group = "build" }
+val assembleNativeMacOsAarch64 = tasks.register("assembleNativeMacOsAarch64") { group = "build" }
 
-val assembleNativeMacOsAmd64 by tasks.registering { group = "build" }
+val assembleNativeMacOsAmd64 = tasks.register("assembleNativeMacOsAmd64") { group = "build" }
 
-val assembleNativeLinuxAarch64 by tasks.registering { group = "build" }
+val assembleNativeLinuxAarch64 = tasks.register("assembleNativeLinuxAarch64") { group = "build" }
 
-val assembleNativeLinuxAmd64 by tasks.registering { group = "build" }
+val assembleNativeLinuxAmd64 = tasks.register("assembleNativeLinuxAmd64") { group = "build" }
 
-val assembleNativeAlpineLinuxAmd64 by tasks.registering { group = "build" }
+val assembleNativeAlpineLinuxAmd64 =
+  tasks.register("assembleNativeAlpineLinuxAmd64") { group = "build" }
 
-val assembleNativeWindowsAmd64 by tasks.registering { group = "build" }
+val assembleNativeWindowsAmd64 = tasks.register("assembleNativeWindowsAmd64") { group = "build" }
 
-val testNativeMacOsAarch64 by tasks.registering { group = "verification" }
+val testNativeMacOsAarch64 = tasks.register("testNativeMacOsAarch64") { group = "verification" }
 
-val testNativeMacOsAmd64 by tasks.registering { group = "verification" }
+val testNativeMacOsAmd64 = tasks.register("testNativeMacOsAmd64") { group = "verification" }
 
-val testNativeLinuxAarch64 by tasks.registering { group = "verification" }
+val testNativeLinuxAarch64 = tasks.register("testNativeLinuxAarch64") { group = "verification" }
 
-val testNativeLinuxAmd64 by tasks.registering { group = "verification" }
+val testNativeLinuxAmd64 = tasks.register("testNativeLinuxAmd64") { group = "verification" }
 
-val testNativeAlpineLinuxAmd64 by tasks.registering { group = "verification" }
+val testNativeAlpineLinuxAmd64 =
+  tasks.register("testNativeAlpineLinuxAmd64") { group = "verification" }
 
-val testNativeWindowsAmd64 by tasks.registering { group = "verification" }
+val testNativeWindowsAmd64 = tasks.register("testNativeWindowsAmd64") { group = "verification" }
 
 val buildInfo = project.extensions.getByType<BuildInfo>()
 
@@ -44,79 +46,85 @@ private fun <T : Task> Task.wraps(other: TaskProvider<T>) {
   outputs.files(other)
 }
 
-val assembleNative by tasks.registering {
-  group = "build"
+val assembleNative =
+  tasks.register("assembleNative") {
+    group = "build"
 
-  if (!buildInfo.isCrossArchSupported && buildInfo.isCrossArch) {
-    throw GradleException("Cross-arch builds are not supported on ${buildInfo.os.name}")
-  }
+    if (!buildInfo.isCrossArchSupported && buildInfo.isCrossArch) {
+      throw GradleException("Cross-arch builds are not supported on ${buildInfo.os.name}")
+    }
 
-  when {
-    buildInfo.os.isMacOsX && buildInfo.targetArch == "aarch64" -> {
-      wraps(assembleNativeMacOsAarch64)
-    }
-    buildInfo.os.isMacOsX && buildInfo.targetArch == "amd64" -> {
-      wraps(assembleNativeMacOsAmd64)
-    }
-    buildInfo.os.isLinux && buildInfo.targetArch == "aarch64" -> {
-      wraps(assembleNativeLinuxAarch64)
-    }
-    buildInfo.os.isLinux && buildInfo.targetArch == "amd64" -> {
-      if (buildInfo.musl) wraps(assembleNativeAlpineLinuxAmd64) else wraps(assembleNativeLinuxAmd64)
-    }
-    buildInfo.os.isWindows && buildInfo.targetArch == "amd64" -> {
-      wraps(assembleNativeWindowsAmd64)
-    }
-    else -> {
-      doLast {
-        throw GradleException(
-          "Cannot build targeting ${buildInfo.os.name}/${buildInfo.targetArch} with musl=${buildInfo.musl}"
-        )
+    when {
+      buildInfo.os.isMacOsX && buildInfo.targetArch == "aarch64" -> {
+        wraps(assembleNativeMacOsAarch64)
+      }
+      buildInfo.os.isMacOsX && buildInfo.targetArch == "amd64" -> {
+        wraps(assembleNativeMacOsAmd64)
+      }
+      buildInfo.os.isLinux && buildInfo.targetArch == "aarch64" -> {
+        wraps(assembleNativeLinuxAarch64)
+      }
+      buildInfo.os.isLinux && buildInfo.targetArch == "amd64" -> {
+        if (buildInfo.musl) wraps(assembleNativeAlpineLinuxAmd64)
+        else wraps(assembleNativeLinuxAmd64)
+      }
+      buildInfo.os.isWindows && buildInfo.targetArch == "amd64" -> {
+        wraps(assembleNativeWindowsAmd64)
+      }
+      else -> {
+        doLast {
+          throw GradleException(
+            "Cannot build targeting ${buildInfo.os.name}/${buildInfo.targetArch} with musl=${buildInfo.musl}"
+          )
+        }
       }
     }
   }
-}
 
-val testNative by tasks.registering {
-  group = "verification"
-  dependsOn(assembleNative)
+val testNative =
+  tasks.register("testNative") {
+    group = "verification"
+    dependsOn(assembleNative)
 
-  if (!buildInfo.isCrossArchSupported && buildInfo.isCrossArch) {
-    throw GradleException("Cross-arch builds are not supported on ${buildInfo.os.name}")
-  }
+    if (!buildInfo.isCrossArchSupported && buildInfo.isCrossArch) {
+      throw GradleException("Cross-arch builds are not supported on ${buildInfo.os.name}")
+    }
 
-  when {
-    buildInfo.os.isMacOsX && buildInfo.targetArch == "aarch64" -> {
-      dependsOn(testNativeMacOsAarch64)
-    }
-    buildInfo.os.isMacOsX && buildInfo.targetArch == "amd64" -> {
-      dependsOn(testNativeMacOsAmd64)
-    }
-    buildInfo.os.isLinux && buildInfo.targetArch == "aarch64" -> {
-      dependsOn(testNativeLinuxAarch64)
-    }
-    buildInfo.os.isLinux && buildInfo.targetArch == "amd64" -> {
-      if (buildInfo.musl) dependsOn(testNativeAlpineLinuxAmd64) else dependsOn(testNativeLinuxAmd64)
-    }
-    buildInfo.os.isWindows && buildInfo.targetArch == "amd64" -> {
-      dependsOn(testNativeWindowsAmd64)
-    }
-    else -> {
-      doLast {
-        throw GradleException(
-          "Cannot build targeting ${buildInfo.os.name}/${buildInfo.targetArch} with musl=${buildInfo.musl}"
-        )
+    when {
+      buildInfo.os.isMacOsX && buildInfo.targetArch == "aarch64" -> {
+        dependsOn(testNativeMacOsAarch64)
+      }
+      buildInfo.os.isMacOsX && buildInfo.targetArch == "amd64" -> {
+        dependsOn(testNativeMacOsAmd64)
+      }
+      buildInfo.os.isLinux && buildInfo.targetArch == "aarch64" -> {
+        dependsOn(testNativeLinuxAarch64)
+      }
+      buildInfo.os.isLinux && buildInfo.targetArch == "amd64" -> {
+        if (buildInfo.musl) dependsOn(testNativeAlpineLinuxAmd64)
+        else dependsOn(testNativeLinuxAmd64)
+      }
+      buildInfo.os.isWindows && buildInfo.targetArch == "amd64" -> {
+        dependsOn(testNativeWindowsAmd64)
+      }
+      else -> {
+        doLast {
+          throw GradleException(
+            "Cannot build targeting ${buildInfo.os.name}/${buildInfo.targetArch} with musl=${buildInfo.musl}"
+          )
+        }
       }
     }
   }
-}
 
-val checkNative by tasks.registering {
-  group = "verification"
-  dependsOn(testNative)
-}
+val checkNative =
+  tasks.register("checkNative") {
+    group = "verification"
+    dependsOn(testNative)
+  }
 
-val buildNative by tasks.registering {
-  group = "build"
-  dependsOn(checkNative)
-}
+val buildNative =
+  tasks.register("buildNative") {
+    group = "build"
+    dependsOn(checkNative)
+  }

build-logic/src/main/kotlin/pklSpotlessFormat.gradle.kts

@@ -15,7 +15,7 @@
  */
 plugins { id("com.diffplug.spotless") }
 
-val pklFormatter by configurations.creating
+val pklFormatter = configurations.create("pklFormatter")
 
 dependencies { pklFormatter(rootProject.project("pkl-formatter")) }