Support the nativeImageCapable criteria

.gitignore

@@ -30,3 +30,6 @@ build
 
 # Ignore IntelliJ IDEA folder
 .idea
+
+# Ignore local publishing repo for testing plugin
+foojay-resolver/repo/

CHANGELOG.md

@@ -4,6 +4,8 @@
 
 ### Added
 
+- Support the nativeImageCapable criteria from JavaToolchainSpec in Gradle 8.14+
+
 ### Changed
 
 ### Deprecated

README.md

@@ -98,7 +98,11 @@ For further information about using Toolchain Download Repositories consult the
 
 # Matching Toolchain Specifications
 
-The main thing the plugin does is to match [Gradle's toolchain specifications](https://docs.gradle.org/current/javadoc/org/gradle/jvm/toolchain/JavaToolchainSpec.html) to foojay DiscoAPI distributions and packages. 
+The main thing the plugin does is to match [Gradle's toolchain specifications](https://docs.gradle.org/current/javadoc/org/gradle/jvm/toolchain/JavaToolchainSpec.html) to foojay DiscoAPI distributions and packages.
+
+## `nativeImageCapable` criteria
+
+When set, it is used to filter out distributions that are not capable of creating native images with GraalVM.
 
 ## Vendors
 

foojay-resolver/build.gradle.kts

@@ -66,6 +66,10 @@ signing {
             project.providers.environmentVariable("PGP_SIGNING_KEY").orNull,
             project.providers.environmentVariable("PGP_SIGNING_KEY_PASSPHRASE").orNull
     )
+
+    setRequired({
+        providers.environmentVariable("CI").isPresent
+    })
 }
 
 testing {

foojay-resolver/src/main/kotlin/org/gradle/toolchains/foojay/FoojayApi.kt

@@ -34,22 +34,24 @@ class FoojayApi {
 
     fun toUri(links: Links?): URI? = links?.pkg_download_redirect
 
+    @Suppress("LongParameterList")
     fun toPackage(
-            version: JavaLanguageVersion,
-            vendor: JvmVendorSpec,
-            implementation: JvmImplementation,
-            operatingSystem: OperatingSystem,
-            architecture: Architecture
+        version: JavaLanguageVersion,
+        vendor: JvmVendorSpec,
+        implementation: JvmImplementation,
+        nativeImageCapable: Boolean,
+        operatingSystem: OperatingSystem,
+        architecture: Architecture
     ): Package? {
-        val distributions = match(vendor, implementation, version)
+        val distributions = match(vendor, implementation, version, nativeImageCapable)
         return distributions.asSequence().mapNotNull { distribution ->
             match(distribution.api_parameter, version, operatingSystem, architecture)
         }.firstOrNull()
     }
 
-    internal fun match(vendor: JvmVendorSpec, implementation: JvmImplementation, version: JavaLanguageVersion): List<Distribution> {
+    internal fun match(vendor: JvmVendorSpec, implementation: JvmImplementation, version: JavaLanguageVersion, nativeImageCapable: Boolean): List<Distribution> {
         fetchDistributionsIfMissing()
-        return match(distributions, vendor, implementation, version)
+        return match(distributions, vendor, implementation, version, nativeImageCapable)
     }
 
     private fun fetchDistributionsIfMissing() {
@@ -68,6 +70,7 @@ class FoojayApi {
     internal fun match(distributionName: String, version: JavaLanguageVersion, operatingSystem: OperatingSystem, architecture: Architecture): Package? {
         val versionApiKey = when {
             distributionName.startsWith("graalvm_community") -> "version"
+            distributionName.equals("graalvm") -> "version"
             else -> "jdk_version"
         }
 

foojay-resolver/src/main/kotlin/org/gradle/toolchains/foojay/FoojayToolchainResolver.kt

@@ -1,25 +1,40 @@
 package org.gradle.toolchains.foojay
 
+import org.gradle.api.provider.Property
 import org.gradle.jvm.toolchain.JavaToolchainDownload
 import org.gradle.jvm.toolchain.JavaToolchainRequest
 import org.gradle.jvm.toolchain.JavaToolchainResolver
+import org.gradle.jvm.toolchain.JavaToolchainSpec
+import org.gradle.util.GradleVersion
 import java.util.*
 
-abstract class FoojayToolchainResolver: JavaToolchainResolver {
+abstract class FoojayToolchainResolver : JavaToolchainResolver {
 
     private val api: FoojayApi = FoojayApi()
 
     override fun resolve(request: JavaToolchainRequest): Optional<JavaToolchainDownload> {
         val spec = request.javaToolchainSpec
+        val nativeImageCapable = if (GradleVersion.current().baseVersion >= GradleVersion.version("8.14")) {
+            extractNativeImageCapability(spec)
+        } else {
+            false
+        }
         val platform = request.buildPlatform
         val links = api.toPackage(
             spec.languageVersion.get(),
             spec.vendor.get(),
             spec.implementation.get(),
+            nativeImageCapable,
             platform.operatingSystem,
             platform.architecture
         )?.links
         val uri = api.toUri(links)
         return Optional.ofNullable(uri).map(JavaToolchainDownload::fromUri)
     }
+
+    @Suppress("UNCHECKED_CAST")
+    private fun extractNativeImageCapability(spec: JavaToolchainSpec): Boolean {
+        val result = spec.javaClass.getMethod("getNativeImageCapable").invoke(spec) as Property<Boolean>
+        return result.getOrElse(false)
+    }
 }

foojay-resolver/src/main/kotlin/org/gradle/toolchains/foojay/distributions.kt

@@ -40,16 +40,22 @@ fun match(
     distributions: List<Distribution>,
     vendor: JvmVendorSpec,
     implementation: JvmImplementation,
-    version: JavaLanguageVersion
+    version: JavaLanguageVersion,
+    nativeImageCapable: Boolean
 ): List<Distribution> {
-    if (implementation == JvmImplementation.J9) return matchForJ9(distributions, vendor)
+    // Start by filtering based on the native image criteria.
+    // If it is defined, we only keep the distributions that have `build_of_graalvm` set to true.
+    val filteredDistributions = distributions.filter { !nativeImageCapable || it.build_of_graalvm }
+
+    // Specific filter when J9 is requested
+    if (implementation == JvmImplementation.J9) return matchForJ9(filteredDistributions, vendor)
 
     // Return early if an explicit non-GraalVM distribution is requested.
-    if (vendor != JvmVendorSpec.GRAAL_VM && vendor != any()) return match(distributions, vendor)
+    if (vendor != JvmVendorSpec.GRAAL_VM && vendor != any()) return match(filteredDistributions, vendor)
 
     // Remove GraalVM distributions that target the wrong Java language version.
     val graalVmCeVendor = JvmVendorSpec.matching("GraalVM CE $version")
-    val distributionsWithoutWrongGraalVm = distributions.filter { (name) ->
+    val distributionsWithoutWrongGraalVm = filteredDistributions.filter { (name) ->
         when {
             // Naming scheme for old GraalVM community releases: The Java language version is part of the name.
             name.startsWith("GraalVM CE") -> graalVmCeVendor.matches(name)

foojay-resolver/src/test/kotlin/org/gradle/toolchains/foojay/FoojayApiTest.kt

@@ -31,7 +31,7 @@ class FoojayApiTest {
         isJ9: Boolean,
         os: OperatingSystem,
         arch: Architecture
-    ) = assertDownloadUri(javaVersion, vendor, isJ9, os, arch)
+    ) = assertDownloadUri(javaVersion, vendor, isJ9, false, os, arch)
 
     companion object {
         @Suppress("DEPRECATION")
@@ -119,17 +119,17 @@ class FoojayApiTest {
     ) {
         assertEquals(
                 listOf(*expectedDistributions),
-                api.match(vendor, implementation, of(version)).map { it.name },
+                api.match(vendor, implementation, of(version), false).map { it.name },
                 "Mismatch in matching distributions for vendor: $vendor, implementation: $implementation, version: $version"
         )
     }
 
     @ParameterizedTest(name = "can resolve arbitrary vendors (Java {0})")
     @ValueSource(ints = [8, 11, 16])
     fun `can resolve arbitrary vendors`(version: Int) {
-        assertEquals("ZuluPrime", api.match(vendorSpec("zuluprime"), VENDOR_SPECIFIC, of(version)).firstOrNull()?.name)
-        assertEquals("ZuluPrime", api.match(vendorSpec("zUluprIme"), VENDOR_SPECIFIC, of(version)).firstOrNull()?.name)
-        assertEquals("JetBrains", api.match(vendorSpec("JetBrains"), VENDOR_SPECIFIC, of(version)).firstOrNull()?.name)
+        assertEquals("ZuluPrime", api.match(vendorSpec("zuluprime"), VENDOR_SPECIFIC, of(version), false).firstOrNull()?.name)
+        assertEquals("ZuluPrime", api.match(vendorSpec("zUluprIme"), VENDOR_SPECIFIC, of(version), false).firstOrNull()?.name)
+        assertEquals("JetBrains", api.match(vendorSpec("JetBrains"), VENDOR_SPECIFIC, of(version), false).firstOrNull()?.name)
     }
 
     @Test
@@ -148,27 +148,46 @@ class FoojayApiTest {
     @Test
     fun `macos arm is mapped to x64 when arm isn't available`() {
         // RISC architecture is preferred when available
-        val p1 = assertDownloadUri(17, AZUL, false, OperatingSystem.MAC_OS, Architecture.AARCH64)
+        val p1 = assertDownloadUri(17, AZUL, false, false,OperatingSystem.MAC_OS, Architecture.AARCH64)
         assertEquals("aarch64", p1.architecture)
 
         // X86 architecture is provided when RISC is not available
-        val p2 = assertDownloadUri(7, AZUL, false, OperatingSystem.MAC_OS, Architecture.AARCH64)
+        val p2 = assertDownloadUri(7, AZUL, false, false, OperatingSystem.MAC_OS, Architecture.AARCH64)
         assertEquals("x64", p2.architecture)
     }
 
+    @Test
+    fun `can pick a native image capable package`() {
+        assertDownloadUri(21, any(), false, true, OperatingSystem.MAC_OS, Architecture.AARCH64)
+    }
+
+    @Test
+    fun `can pick graalvm package`() {
+        assertDownloadUri(21, matching("GraalVM"), false, true, OperatingSystem.MAC_OS, Architecture.AARCH64)
+    }
+
     @Suppress("LongParameterList")
     private fun assertDownloadUri(
             javaVersion: Int,
             vendor: JvmVendorSpec,
             isJ9: Boolean,
+            nativeImageCapable: Boolean,
             os: OperatingSystem,
             arch: Architecture
     ): Package {
-        val actual = api.toPackage(of(javaVersion), vendor, if (isJ9) J9 else VENDOR_SPECIFIC, os, arch)
+        val actual = api.toPackage(
+            of(javaVersion),
+            vendor,
+            if (isJ9) J9 else VENDOR_SPECIFIC,
+            nativeImageCapable,
+            os,
+            arch
+        )
         assertNotNull(actual)
         assertNotNull(actual.links.pkg_download_redirect)
         assertJavaVersion(javaVersion, actual)
         assertDistribution(vendor, actual)
+        assertNativeImageCapable(nativeImageCapable, vendor, actual)
         assertOperatingSystem(os, actual)
         assertArchitecture(os, arch, actual)
         return actual
@@ -196,6 +215,18 @@ class FoojayApiTest {
         )
     }
 
+    private fun assertNativeImageCapable(nativeImageCapable: Boolean, vendor: JvmVendorSpec, actual: Package) {
+        if (nativeImageCapable) {
+            // TODO this is not a great test, but the package does not carry the native-image / Graal capability information anymore
+            if (vendor == any()) {
+                assertTrue(actual.distribution.contains("mandrel"),
+                    "Expected vendor to contain 'mandrel' when native image capable, got ${actual.distribution}")
+            } else {
+                assertDistribution(vendor, actual)
+            }
+        }
+    }
+
     private fun assertOperatingSystem(os: OperatingSystem, actual: Package) {
         val expectedValue = os.toString().replace("_", "").lowercase()
         val actualValue = actual.operating_system