Drop java 11, bump GraalVM to 23.0 (#439)

* Remove unnecessary strictfp modifier
* Add annotations to address Truffle DSL warnings (@Idempotent, @Exclusive)
* Adjust build logic to allow building cross-arch on macOS
* Add warning suppression for specialization limit (left this one as a TODO)

buildSrc/build.gradle.kts

@@ -18,15 +18,15 @@ dependencies {
 }
 
 java {
-  sourceCompatibility = JavaVersion.VERSION_11
-  targetCompatibility = JavaVersion.VERSION_11
+  sourceCompatibility = JavaVersion.VERSION_17
+  targetCompatibility = JavaVersion.VERSION_17
 }
 
 kotlin {
   target {
     compilations.configureEach {
       kotlinOptions {
-        jvmTarget = "11"
+        jvmTarget = "17"
       }
     }
   }

buildSrc/src/main/kotlin/BuildInfo.kt

@@ -9,9 +9,7 @@ import org.gradle.kotlin.dsl.getByType
 // `buildInfo` in main build scripts
 // `project.extensions.getByType<BuildInfo>()` in precompiled script plugins
 open class BuildInfo(project: Project) {
-  val self = this
-
-  inner class GraalVm {
+  inner class GraalVm(val arch: String) {
     val homeDir: String by lazy {
       System.getenv("GRAALVM_HOME") ?: "${System.getProperty("user.home")}/.graalvm"
     }
@@ -20,21 +18,12 @@ open class BuildInfo(project: Project) {
       libs.findVersion("graalVm").get().toString()
     }
 
-    val isGraal22: Boolean by lazy {
-      version.startsWith("22")
-    }
-
-    val arch by lazy {
-      if (os.isMacOsX && isGraal22) {
-        "amd64"
-      } else {
-        self.arch
-      }
+    val graalVmJdkVersion: String by lazy {
+      libs.findVersion("graalVmJdkVersion").get().toString()
     }
 
     val osName: String by lazy {
       when {
-        os.isMacOsX && isGraal22 -> "darwin"
         os.isMacOsX -> "macos"
         os.isLinux -> "linux"
         else -> throw RuntimeException("${os.familyName} is not supported.")
@@ -42,25 +31,12 @@ open class BuildInfo(project: Project) {
     }
 
     val baseName: String by lazy {
-      if (graalVm.isGraal22) {
-        "graalvm-ce-java11-${osName}-${arch}-${version}"
-      } else {
-        "graalvm-jdk-${graalVM23JdkVersion}_${osName}-${arch}_bin"
-      }
-    }
-
-    val graalVM23JdkVersion: String by lazy {
-      libs.findVersion("graalVM23JdkVersion").get().requiredVersion
+      "graalvm-jdk-${graalVmJdkVersion}_${osName}-${arch}_bin"
     }
 
     val downloadUrl: String by lazy {
-      if (isGraal22) {
-        "https://github.com/graalvm/graalvm-ce-builds/releases/download/vm-" +
-          "${version}/$baseName.tar.gz"
-      } else {
-        val jdkMajor = graalVM23JdkVersion.takeWhile { it != '.' }
-        "https://download.oracle.com/graalvm/$jdkMajor/archive/$baseName.tar.gz"
-      }
+      val jdkMajor = graalVmJdkVersion.takeWhile { it != '.' }
+      "https://download.oracle.com/graalvm/$jdkMajor/archive/$baseName.tar.gz"
     }
 
     val installDir: File by lazy {
@@ -84,7 +60,9 @@ open class BuildInfo(project: Project) {
     }
   }
 
-  val graalVm: GraalVm = GraalVm()
+  val graalVmAarch64: GraalVm = GraalVm("aarch64")
+
+  val graalVmAmd64: GraalVm = GraalVm("x64")
 
   val isCiBuild: Boolean by lazy {
     System.getenv("CI") != null

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

@@ -24,13 +24,13 @@ configurations {
 
 plugins.withType(JavaPlugin::class).configureEach {
   val java = project.extensions.getByType<JavaPluginExtension>()
-  java.sourceCompatibility = JavaVersion.VERSION_11
-  java.targetCompatibility = JavaVersion.VERSION_11
+  java.sourceCompatibility = JavaVersion.VERSION_17
+  java.targetCompatibility = JavaVersion.VERSION_17
 }
 
 tasks.withType<KotlinCompile>().configureEach {
   kotlinOptions {
-    jvmTarget = "11"
+    jvmTarget = "17"
     freeCompilerArgs = freeCompilerArgs + listOf("-Xjsr305=strict", "-Xjvm-default=all")
   }
 }

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

@@ -9,55 +9,80 @@ plugins {
 
 val buildInfo = project.extensions.getByType<BuildInfo>()
 
-val homeDir = buildInfo.graalVm.homeDir
-val baseName = buildInfo.graalVm.baseName
-val installDir = buildInfo.graalVm.installDir
-val downloadUrl = buildInfo.graalVm.downloadUrl
-val downloadFile = file(homeDir).resolve("$baseName.tar.gz")
+val BuildInfo.GraalVm.downloadFile get() = file(homeDir).resolve("${baseName}.tar.gz")
 
 // tries to minimize chance of corruption by download-to-temp-file-and-move
-val downloadGraalVm by tasks.registering(Download::class) {
+val downloadGraalVmAarch64 by tasks.registering(Download::class) {
+  configureDownloadGraalVm(buildInfo.graalVmAarch64)
+}
+
+val downloadGraalVmAmd64 by tasks.registering(Download::class) {
+  configureDownloadGraalVm(buildInfo.graalVmAmd64)
+}
+
+fun Download.configureDownloadGraalVm(graalvm: BuildInfo.GraalVm) {
   onlyIf {
-    !installDir.exists()
+    !graalvm.installDir.exists()
+  }
+  doLast {
+    println("Downloaded GraalVm to ${graalvm.downloadFile}")
   }
 
-  src(downloadUrl)
-  dest(downloadFile)
+  src(graalvm.downloadUrl)
+  dest(graalvm.downloadFile)
   overwrite(false)
   tempAndMove(true)
 }
 
-val verifyGraalVm by tasks.registering(Verify::class) {
+val verifyGraalVmAarch64 by tasks.registering(Verify::class) {
+  configureVerifyGraalVm(buildInfo.graalVmAarch64)
+  dependsOn(downloadGraalVmAarch64)
+}
+
+val verifyGraalVmAmd64 by tasks.registering(Verify::class) {
+  configureVerifyGraalVm(buildInfo.graalVmAmd64)
+  dependsOn(downloadGraalVmAmd64)
+}
+
+fun Verify.configureVerifyGraalVm(graalvm: BuildInfo.GraalVm) {
   onlyIf {
-    !installDir.exists()
+    !graalvm.installDir.exists()
   }
 
-  dependsOn(downloadGraalVm)
-  src(downloadFile)
-  checksum(buildInfo.libs.findVersion("graalVmSha256-${buildInfo.graalVm.osName}-${buildInfo.graalVm.arch}").get().toString())
+  src(graalvm.downloadFile)
+  checksum(buildInfo.libs.findVersion("graalVmSha256-${graalvm.osName}-${graalvm.arch}").get().toString())
   algorithm("SHA-256")
 }
 
 // minimize chance of corruption by extract-to-random-dir-and-flip-symlink
-val installGraalVm by tasks.registering {
-  dependsOn(verifyGraalVm)
+val installGraalVmAarch64 by tasks.registering {
+  dependsOn(verifyGraalVmAarch64)
+  configureInstallGraalVm(buildInfo.graalVmAarch64)
+}
 
+// minimize chance of corruption by extract-to-random-dir-and-flip-symlink
+val installGraalVmAmd64 by tasks.registering {
+  dependsOn(verifyGraalVmAmd64)
+  configureInstallGraalVm(buildInfo.graalVmAmd64)
+}
+
+fun Task.configureInstallGraalVm(graalVm: BuildInfo.GraalVm) {
   onlyIf {
-    !installDir.exists()
+    !graalVm.installDir.exists()
   }
 
   doLast {
-    val distroDir = "$homeDir/${UUID.randomUUID()}"
+    val distroDir = "${graalVm.homeDir}/${UUID.randomUUID()}"
 
     try {
       mkdir(distroDir)
 
-      println("Extracting $downloadFile into $distroDir")
+      println("Extracting ${graalVm.downloadFile} into $distroDir")
       // faster and more reliable than Gradle's `copy { from tarTree() }`
       exec {
         workingDir = file(distroDir)
         executable = "tar"
-        args("--strip-components=1", "-xzf", downloadFile)
+        args("--strip-components=1", "-xzf", graalVm.downloadFile)
       }
 
       val distroBinDir = if (buildInfo.os.isMacOsX) "$distroDir/Contents/Home/bin" else "$distroDir/bin"
@@ -68,11 +93,11 @@ val installGraalVm by tasks.registering {
         args("install", "--no-progress", "native-image")
       }
 
-      println("Creating symlink $installDir for $distroDir")
-      val tempLink = Paths.get("$homeDir/${UUID.randomUUID()}")
+      println("Creating symlink ${graalVm.installDir} for $distroDir")
+      val tempLink = Paths.get("${graalVm.homeDir}/${UUID.randomUUID()}")
       Files.createSymbolicLink(tempLink, Paths.get(distroDir))
       try {
-        Files.move(tempLink, installDir.toPath(), StandardCopyOption.ATOMIC_MOVE)
+        Files.move(tempLink, graalVm.installDir.toPath(), StandardCopyOption.ATOMIC_MOVE)
       } catch (e: Exception) {
         try { delete(tempLink.toFile()) } catch (ignored: Exception) {}
         throw e

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

@@ -61,4 +61,7 @@ val workAroundKotlinGradlePluginBug by tasks.registering {
 
 tasks.compileJava {
   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")
 }