Upgrade GraalVM and Truffle, set up multi-JDK testing, bump development Java to 21 (#876)

This updates the GraalVM and Truffle libraries to 2024.1.2.

This also updates the build logic to compile Java sources using Java 21, due to some compile-only dependencies within GraalVM/Truffle using class file version 65. However, the produced artifact is still compatible with Java 17.

This also changes the Gradle build logic to use toolchains, and to test the Java libraries with JDK 17 and 21.

One consequence of this change is that Truffle is no longer shaded within the fat jars.

feat: support for jvm21+ toolchain
feat: support for gradle toolchains
feat: pass -PnativeArch=native to build with -march=native
test: multi-jdk testing support
test: support for jvm-test-suite plugin
test: add tasks to run jpkl eval on multiple jdks
test: make jdk exec tests respect multi-jdk flags and ranges
fix: remove mrjar classes at >jvm17 from fatjars
fix: use jdk21 to run the tests (needed for Unsafe.ensureInitialized)
fix: truffle svm dependency is required after graalvm 24.0.0
fix: warnings for gvm flag usage, renamed truffle svm macro
fix: build with --add-modules=jdk.unsupported where needed
fix: don't use gu tool for modern graalvm versions
fix: catch Throwable instead of deprecated-for-removal ThreadDeath
chore: buildinfo changes for JVM targets, toolchains
chore: enforce testing at exactly jdk21
chore: enforce build tooling at jdk21+
chore: bump graalvm/truffle libs → 24.1.2
chore: toolchains for buildSrc

Signed-off-by: Sam Gammon <sam@elide.dev>

buildSrc/src/main/kotlin/pklJavaLibrary.gradle.kts

@@ -1,5 +1,5 @@
 /*
- * Copyright © 2024 Apple Inc. and the Pkl project authors. All rights reserved.
+ * Copyright © 2024-2025 Apple Inc. and the Pkl project authors. All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -13,25 +13,39 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-@file:Suppress("HttpUrlsUsage")
+@file:Suppress("HttpUrlsUsage", "unused")
 
 import org.gradle.accessors.dm.LibrariesForLibs
 
 plugins {
   `java-library`
+  `jvm-toolchains`
   id("pklKotlinTest")
   id("com.diffplug.spotless")
 }
 
 // make sources Jar available to other subprojects
-val sourcesJarConfiguration = configurations.register("sourcesJar")
+val sourcesJarConfiguration: Provider<Configuration> = configurations.register("sourcesJar")
 
 // Version Catalog library symbols.
 val libs = the<LibrariesForLibs>()
 
+// Build configuration.
+val info = project.extensions.getByType<BuildInfo>()
+
 java {
+  val jvmTarget = JavaVersion.toVersion(info.jvmTarget)
+
   withSourcesJar() // creates `sourcesJar` task
   withJavadocJar()
+
+  sourceCompatibility = jvmTarget
+  targetCompatibility = jvmTarget
+
+  toolchain {
+    languageVersion = info.jdkToolchainVersion
+    vendor = info.jdkVendor
+  }
 }
 
 artifacts {
@@ -56,7 +70,11 @@ tasks.compileKotlin { enabled = false }
 
 tasks.jar {
   manifest {
-    attributes += mapOf("Automatic-Module-Name" to "org.${project.name.replace("-", ".")}")
+    attributes +=
+      mapOf(
+        "Automatic-Module-Name" to "org.${project.name.replace("-", ".")}",
+        "Add-Exports" to info.jpmsExportsForJarManifest,
+      )
   }
 }
 
@@ -80,9 +98,48 @@ val workAroundKotlinGradlePluginBug by
     }
   }
 
+val truffleJavacArgs =
+  listOf(
+    // TODO: determine correct limits for Truffle specializations
+    // (see https://graalvm.slack.com/archives/CNQSB2DHD/p1712380902746829)
+    "-Atruffle.dsl.SuppressWarnings=truffle-limit"
+  )
+
 tasks.compileJava {
+  javaCompiler = info.javaCompiler
   dependsOn(workAroundKotlinGradlePluginBug)
-  // TODO: determine correct limits for Truffle specializations
-  // (see https://graalvm.slack.com/archives/CNQSB2DHD/p1712380902746829)
-  options.compilerArgs.add("-Atruffle.dsl.SuppressWarnings=truffle-limit")
+  options.compilerArgs.addAll(truffleJavacArgs + info.jpmsAddModulesFlags)
 }
+
+tasks.withType<JavaCompile>().configureEach {
+  val jvmTarget = JavaVersion.toVersion(info.jvmTarget)
+  javaCompiler = info.javaCompiler
+  sourceCompatibility = jvmTarget.majorVersion
+  targetCompatibility = jvmTarget.majorVersion
+}
+
+tasks.withType<JavaExec>().configureEach { jvmArgs(info.jpmsAddModulesFlags) }
+
+fun Test.configureJdkTestTask(launcher: Provider<JavaLauncher>) {
+  useJUnitPlatform()
+  javaLauncher = launcher
+  systemProperties.putAll(info.testProperties)
+  jvmArgs.addAll(info.jpmsAddModulesFlags)
+}
+
+tasks.test { configureJdkTestTask(info.javaTestLauncher) }
+
+// Prepare test tasks for each JDK version which is within the test target suite for Pkl. Each task
+// uses a pinned JDK toolchain version, and is named for the major version which is tested.
+//
+// Test tasks configured in this manner are executed manually by name, e.g. `./gradlew testJdk11`,
+// and automatically as dependencies of `check`.
+//
+// We omit the current JDK from this list because it is already tested, in effect, by the default
+// `test` task.
+//
+// Pkl subprojects may elect to further configure these tasks as needed; by default, each task
+// inherits the configuration of the default `test` task (aside from an overridden launcher).
+val jdkTestTasks = info.multiJdkTestingWith(tasks.test) { (_, jdk) -> configureJdkTestTask(jdk) }
+
+if (info.multiJdkTesting) tasks.check { dependsOn(jdkTestTasks) }