Run the value class tests on JDK 28 early access

JEP 401 was integrated into JDK 28 on 2026-07-31, so its early-access
builds are the JDK with value classes, and Temurin's come through
actions/setup-java as 28-ea. The leg replaces the jdk.java.net Valhalla
build pinned two commits ago: that line, based on JDK 27, declares
VALUE between NON_SEALED and FINAL in javax.lang.model.element.Modifier
and so sorted `value final public` to `public value final`. Mainline
declares VALUE last, after STRICTFP, and sorts it to `public final
value`, the order upstream's tests expect; the tests expect it again.

Author: abashev

.github/workflows/ci.yml

@@ -50,7 +50,7 @@ jobs:
   # formatter parses with. The IntelliJ plugin's tests stay on the runtime of the IDE they start.
   # JDK 21 itself is `build`, the check the default branch requires.
   jdk:
-    name: build (JDK ${{ matrix.jdk }}${{ matrix.valhalla && ', Valhalla EA' || '' }})
+    name: build (JDK ${{ matrix.jdk }}${{ matrix.ea && '-ea' || '' }})
     runs-on: ubuntu-latest
     strategy:
       fail-fast: false
@@ -68,40 +68,25 @@ jobs:
               Gradle 9.7.1 does not run on Java 27 yet, and the Gradle plugin's tests run their TestKit builds on
               the test JVM, where they fail with "Unsupported class file major version 71". Those tests are left
               out until the wrapper's Gradle supports Java 27.
-          # The JEP 401 early-access build from https://jdk.java.net/valhalla/, the one JDK with value classes
-          # until they reach a release: the value class tests (#131) are skipped on every other JDK. No
-          # setup-java distribution serves it, so the build is pinned here by URL and checksum from the
-          # download page; bump both when a newer build appears there.
-          - jdk: 27
-            valhalla: https://download.java.net/java/early_access/valhalla/27/1/openjdk-27-jep401ea3+1-1_linux-x64_bin.tar.gz
-            valhalla_sha256: b8bdd7b181c6a5ea2dd9959255e222cd9d9a9f42cca4f2400991b9b2ff7ffb7d
+          # Value classes (JEP 401) are a preview feature of JDK 28, so until it is released the `value` modifier
+          # tests (#131) run on its early-access builds and are skipped everywhere else.
+          - jdk: 28
+            ea: true
             gradle_args: -x :gradle-open-java-format:test
-            gradle_args_reason: As for JDK 27, the release this build is based on.
+            gradle_args_reason: As on JDK 27, the wrapper's Gradle does not run on Java 28 either.
     steps:
       - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
         with:
           persist-credentials: false
 
-      - name: Download the Valhalla early-access JDK
-        if: ${{ matrix.valhalla }}
-        id: valhalla
-        env:
-          URL: ${{ matrix.valhalla }}
-          SHA256: ${{ matrix.valhalla_sha256 }}
-        run: |
-          curl --fail --silent --show-error --location --output "$RUNNER_TEMP/valhalla.tar.gz" "$URL"
-          echo "$SHA256  $RUNNER_TEMP/valhalla.tar.gz" | sha256sum --check
-          echo "archive=$RUNNER_TEMP/valhalla.tar.gz" >> "$GITHUB_OUTPUT"
-
-      # No problem matcher in this job: `build` annotates the warnings. The Valhalla build is the archive
-      # downloaded above: jdkfile is the distribution for a JDK that setup-java did not fetch itself.
+      # No problem matcher in this job: `build` annotates the warnings. An `ea` leg takes the newest
+      # early-access build of its version.
       - name: Install JDK ${{ matrix.jdk }} for the tests
         id: test-jdk
         uses: actions/setup-java@de7274f081f381c8f8158605e0321c36c376e2e6 # v6.0.1
         with:
-          distribution: ${{ matrix.valhalla && 'jdkfile' || 'temurin' }}
-          jdk-file: ${{ steps.valhalla.outputs.archive }}
-          java-version: ${{ matrix.jdk }}
+          distribution: temurin
+          java-version: ${{ matrix.jdk }}${{ matrix.ea && '-ea' || '' }}
           problem-matcher: false
 
       # Installed last, so that it is the JAVA_HOME Gradle runs and compiles on.

README.md

@@ -138,9 +138,9 @@ mise trust && mise install
 ```
 
 `-PjavaRuntime=25` runs the same tests on JDK 25, as CI's `jdk` jobs do for 25, 26 and 27, and for
-the Valhalla early-access build, the one JDK whose value classes the `value` modifier tests need.
-The code is compiled for Java 21 either way. Gradle has to find that JDK: installed with mise, or
-named with `-Porg.gradle.java.installations.paths=/path/to/jdk`.
+the early-access builds of 28, where value classes are a preview feature and the `value` modifier
+tests run. The code is compiled for Java 21 either way. Gradle has to find that JDK: installed with
+mise, or named with `-Porg.gradle.java.installations.paths=/path/to/jdk`.
 
 Nothing inside the build downloads a JDK. `gradle.properties` turns toolchain auto-download off and
 reads the installations from `JDK21_HOME` and `GRAALVM_HOME`, so a missing JDK is an error you can

open-java-format/src/test/java/com/palantir/javaformat/java/FormatterTest.java

@@ -592,11 +592,8 @@ value final public class PointValueClass {
 
             value public record PointValueRecord(int x, int y) {}
             """;
-        // The orderer follows the Modifier enum, and the JEP 401 early-access builds declare VALUE between NON_SEALED
-        // and FINAL. Upstream expects `final value`, the order of Valhalla's lworld branch, where VALUE comes last.
-        // Re-check when CI moves to a newer build.
         String expected = """
-            public value final class PointValueClass {
+            public final value class PointValueClass {
                 final int x;
                 final int y;
 

open-java-format/src/test/java/com/palantir/javaformat/java/ModifierOrdererTest.java

@@ -121,10 +121,8 @@ void valueClass() throws FormatterException {
                 Arrays.stream(Modifier.values())
                         .anyMatch(modifier -> modifier.name().equals("VALUE")),
                 "`value` is a modifier only on a JDK with Project Valhalla's value classes");
-        // The JEP 401 early-access builds declare VALUE between NON_SEALED and FINAL; upstream expects `final value`,
-        // the order of Valhalla's lworld branch, where VALUE comes last. Re-check when CI moves to a newer build.
         assertThat(ModifierOrderer.reorderModifiers("value final public").getText())
-                .isEqualTo("public value final");
+                .isEqualTo("public final value");
     }
 
     @Test