@@ -55,19 +55,33 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
+        # `gradle` is what the Gradle plugins' tests build their projects with: the oldest release that runs on
+        # the leg's JDK (https://docs.gradle.org/current/userguide/compatibility.html#java_runtime), or 9.3.1,
+        # the oldest the plugins support, where that is older. Each leg thus tests the far end of what it can.
+        # 28-ea has none that runs on it yet.
         include:
           - jdk: 25
+            gradle: 9.3.1
             gradle_args: ''
             gradle_args_reason: ''
           - jdk: 26
+            gradle: 9.4.0
             gradle_args: ''
             gradle_args_reason: ''
           - jdk: 27
+            gradle: 9.8.0
+            gradle_args: ''
+            gradle_args_reason: ''
+          # 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. The version is spelled
+          # as setup-java spells it; Gradle gets the number alone.
+          - jdk: 28-ea
+            gradle: ''
             gradle_args: -x :gradle-open-java-format:test
             gradle_args_reason: >-
-              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.
+              No Gradle release runs on Java 28 yet: 9.8.2, the newest, fails to compile a build script there with
+              "Unsupported class file major version 72". The Gradle plugins' tests build their projects with Gradle
+              on the test JVM, so they are left out until a release runs on it.
     steps:
       - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
         with:
@@ -99,11 +113,14 @@ jobs:
 
       # Gradle does not look into the runner's tool cache, so it is told where the test JDK is. The path is
       # a step's output, so it reaches the shell as a variable rather than being pasted into the script.
+      # -PjavaRuntime takes a number, so an early-access leg loses its -ea suffix here.
       - name: Build
         env:
           TEST_JDK: ${{ steps.test-jdk.outputs.path }}
+          JDK: ${{ matrix.jdk }}
+          TESTKIT_GRADLE: ${{ matrix.gradle }}
         run: >-
-          ./gradlew test -PjavaRuntime=${{ matrix.jdk }} ${{ matrix.gradle_args }}
+          ./gradlew test -PjavaRuntime="${JDK%-ea}" -PtestkitGradleVersion="$TESTKIT_GRADLE" ${{ matrix.gradle_args }}
           -Porg.gradle.java.installations.paths="$TEST_JDK"
 
       - name: Publish Test Report
 
@@ -137,9 +137,14 @@ mise trust && mise install
 ./gradlew test      # what the CI build job runs
 ```
 
-`-PjavaRuntime=25` runs the same tests on JDK 25, as CI's `jdk` jobs do for 25, 26 and 27. 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`.
+`-PjavaRuntime=25` runs the same tests on JDK 25, as CI's `jdk` jobs do for 25, 26 and 27, and for
+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`.
+
+The Gradle plugins' tests build their projects with Gradle 9.3.1, the oldest the plugins support.
+`-PtestkitGradleVersion=9.8.0` builds them with another, as CI's JDK 27 leg does: 9.3.1 does not run
+on Java 27, and 9.8.0 is the oldest release that does.
 
 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
 
@@ -147,6 +147,13 @@ def writeNativeImagePath = tasks.register("writeNativeImagePath") {
 tasks.named("test").configure {
     dependsOn(writeImplClasspath)
 
+    // The Gradle the TestKit builds run on, read by GradleTestProject, which defaults to the oldest Gradle 9
+    // the plugins support. CI's jdk legs pass the oldest release that runs on their JDK; empty means none.
+    def testkitGradleVersion = providers.gradleProperty('testkitGradleVersion').filter { !it.isEmpty() }
+    if (testkitGradleVersion.isPresent()) {
+        systemProperty 'testkit.gradleVersion', testkitGradleVersion.get()
+    }
+
     if (rootProject.ext.nativeImageRequested) {
         dependsOn(writeNativeImagePath)
     } else {
 
@@ -45,10 +45,12 @@
 public final class GradleTestProject {
 
     /**
-     * The oldest Gradle 9 we claim to support — the interesting end of the range to test against. There is no version
-     * matrix any more: Gradle 8 was dropped when the build itself moved to 9.
+     * The Gradle the generated projects build with: the oldest Gradle 9 we claim to support, the interesting end of
+     * the range to test against. There is no version matrix any more: Gradle 8 was dropped when the build itself moved
+     * to 9. On a JDK that old a Gradle cannot run on, the build names the oldest one that can in
+     * {@code testkit.gradleVersion}; CI's jdk legs take it from Gradle's compatibility table.
      */
-    private static final String GRADLE_VERSION = "9.3.1";
+    private static final String GRADLE_VERSION = System.getProperty("testkit.gradleVersion", "9.3.1");
 
     /** Written by java-gradle-plugin: the classpath {@link GradleRunner#withPluginClasspath()} injects. */
     private static final String PLUGIN_METADATA = "plugin-under-test-metadata.properties";
 
@@ -1,7 +1,9 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-9.8.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-9.8.2-bin.zip
 networkTimeout=10000
+retries=0
+retryBackOffMs=500
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
@@ -34,6 +34,7 @@
 import static com.sun.source.tree.Tree.Kind.STRING_LITERAL;
 import static java.util.stream.Collectors.toList;
 
+import com.google.common.base.Enums;
 import com.google.common.base.MoreObjects;
 import com.google.common.base.Predicate;
 import com.google.common.base.Throwables;
@@ -146,6 +147,7 @@
 import java.util.regex.Pattern;
 import java.util.stream.Stream;
 import javax.annotation.Nullable;
+import javax.lang.model.element.Modifier;
 import javax.lang.model.element.Name;
 
 /** An AST visitor that builds a stream of {@link Op}s to format from the given {@link CompilationUnitTree}. */
@@ -1420,8 +1422,11 @@ public Void visitMethod(MethodTree node, Void unused) {
                 }
             }
         }
-        builder.addAll(
-                visitModifiers(annotations, Direction.VERTICAL, /* declarationAnnotationBreak= */ Optional.empty()));
+        builder.addAll(visitModifiers(
+                annotations,
+                node.getModifiers().getFlags(),
+                Direction.VERTICAL,
+                /* declarationAnnotationBreak= */ Optional.empty()));
 
         Tree baseReturnType = null;
         Deque<List<? extends AnnotationTree>> dims = null;
@@ -2236,30 +2241,36 @@ protected List<Op> visitModifiers(
             Optional<BreakTag> declarationAnnotationBreak) {
         boolean isRecordParameter = modifiersTree instanceof JCTree.JCModifiers && isInRecord(modifiersTree);
         return visitModifiers(
-                modifiersTree.getAnnotations(), annotationsDirection, declarationAnnotationBreak, isRecordParameter);
+                modifiersTree.getAnnotations(),
+                modifiersTree.getFlags(),
+                annotationsDirection,
+                declarationAnnotationBreak,
+                isRecordParameter);
     }
 
     private List<Op> visitModifiers(
             List<? extends AnnotationTree> annotationTrees,
+            Set<Modifier> flags,
             Direction annotationsDirection,
             Optional<BreakTag> declarationAnnotationBreak) {
-        return visitModifiers(annotationTrees, annotationsDirection, declarationAnnotationBreak, false);
+        return visitModifiers(annotationTrees, flags, annotationsDirection, declarationAnnotationBreak, false);
     }
 
     private List<Op> visitModifiers(
             List<? extends AnnotationTree> annotationTrees,
+            Set<Modifier> flags,
             Direction annotationsDirection,
             Optional<BreakTag> declarationAnnotationBreak,
             boolean isRecordParameter) {
-        if (annotationTrees.isEmpty() && !nextIsModifier()) {
+        if (annotationTrees.isEmpty() && !nextIsModifier(flags)) {
             return EMPTY_LIST;
         }
         Deque<AnnotationTree> annotations = new ArrayDeque<>(annotationTrees);
         builder.open(ZERO);
         boolean first = true;
         boolean lastWasAnnotation = false;
         while (!annotations.isEmpty()) {
-            if (nextIsModifier()) {
+            if (nextIsModifier(flags)) {
                 break;
             }
             if (!first) {
@@ -2286,7 +2297,7 @@ private List<Op> visitModifiers(
                 : annotationsDirection.isVertical()
                         ? forceBreakList(declarationAnnotationBreak)
                         : breakList(declarationAnnotationBreak);
-        if (annotations.isEmpty() && !nextIsModifier()) {
+        if (annotations.isEmpty() && !nextIsModifier(flags)) {
             return trailingBreak;
         }
         if (lastWasAnnotation) {
@@ -2295,11 +2306,11 @@ private List<Op> visitModifiers(
 
         builder.open(ZERO);
         first = true;
-        while (nextIsModifier() || !annotations.isEmpty()) {
+        while (nextIsModifier(flags) || !annotations.isEmpty()) {
             if (!first) {
                 builder.addAll(breakFillList(Optional.empty()));
             }
-            if (nextIsModifier()) {
+            if (nextIsModifier(flags)) {
                 String currentToken = builder.peekToken().get();
                 token(currentToken);
                 if (currentToken.equals("non")) {
@@ -2316,23 +2327,39 @@ private List<Op> visitModifiers(
         return breakFillList(Optional.empty());
     }
 
-    boolean nextIsModifier() {
+    /**
+     * The {@code value} modifier of Project Valhalla's value classes, on a JDK that has it. It is looked up by name so
+     * that the formatter still compiles for JDK 21.
+     */
+    @Nullable
+    private static final Modifier VALUE_MODIFIER =
+            Enums.getIfPresent(Modifier.class, "VALUE").orNull();
+
+    /**
+     * Whether the next token is one of {@code flags}, the modifiers of the declaration being visited. The text alone
+     * does not tell the contextual modifiers {@code sealed} and {@code value} from identifiers of that name, and a
+     * lambda parameter named so starts its declaration with it.
+     */
+    boolean nextIsModifier(Set<Modifier> flags) {
+        if (flags.isEmpty()) {
+            return false;
+        }
         return switch (builder.peekToken().get()) {
-            case "public",
-                    "protected",
-                    "private",
-                    "abstract",
-                    "static",
-                    "final",
-                    "transient",
-                    "volatile",
-                    "synchronized",
-                    "native",
-                    "strictfp",
-                    "default",
-                    "sealed",
-                    "non",
-                    "-" -> true;
+            case "public" -> flags.contains(Modifier.PUBLIC);
+            case "protected" -> flags.contains(Modifier.PROTECTED);
+            case "private" -> flags.contains(Modifier.PRIVATE);
+            case "abstract" -> flags.contains(Modifier.ABSTRACT);
+            case "static" -> flags.contains(Modifier.STATIC);
+            case "final" -> flags.contains(Modifier.FINAL);
+            case "transient" -> flags.contains(Modifier.TRANSIENT);
+            case "volatile" -> flags.contains(Modifier.VOLATILE);
+            case "synchronized" -> flags.contains(Modifier.SYNCHRONIZED);
+            case "native" -> flags.contains(Modifier.NATIVE);
+            case "strictfp" -> flags.contains(Modifier.STRICTFP);
+            case "default" -> flags.contains(Modifier.DEFAULT);
+            case "sealed" -> flags.contains(Modifier.SEALED) || flags.contains(Modifier.NON_SEALED);
+            case "non", "-" -> flags.contains(Modifier.NON_SEALED);
+            case "value" -> VALUE_MODIFIER != null && flags.contains(VALUE_MODIFIER);
             default -> false;
         };
     }
 
@@ -19,6 +19,7 @@
 import static com.google.common.base.Preconditions.checkState;
 import static com.google.common.collect.Iterables.getLast;
 
+import com.google.common.base.Enums;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Ordering;
 import com.google.common.collect.Range;
@@ -201,7 +202,7 @@ private static Modifier asModifier(ImmutableList<Token> tokens) {
         if (modifier == null) {
             return null;
         }
-        return Modifier.valueOf("NON_" + modifier.name());
+        return Enums.getIfPresent(Modifier.class, "NON_" + modifier.name()).orNull();
     }
 
     /**
@@ -254,6 +255,7 @@ private static Modifier asModifier(Token token) {
         }
         return switch (token.getTok().getText()) {
             case "sealed" -> Modifier.valueOf("SEALED");
+            case "value" -> Enums.getIfPresent(Modifier.class, "VALUE").orNull();
             default -> null;
         };
     }
 
@@ -34,12 +34,16 @@
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.time.Duration;
+import java.util.Arrays;
 import java.util.List;
+import javax.lang.model.element.Modifier;
 import org.junit.jupiter.api.Assumptions;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.io.TempDir;
 import org.junit.jupiter.api.parallel.Execution;
 import org.junit.jupiter.api.parallel.ExecutionMode;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
 
 @Execution(ExecutionMode.CONCURRENT)
 final class FormatterTest {
@@ -568,4 +572,68 @@ void removeTrailingTabsInComments() throws FormatterException {
 
         assertThat(formatter.formatSource(input)).isEqualTo(expected);
     }
+
+    @Test
+    void valueClassAndRecord() throws FormatterException {
+        Assumptions.assumeTrue(
+                Arrays.stream(Modifier.values())
+                        .anyMatch(modifier -> modifier.name().equals("VALUE")),
+                "`value` is a modifier only on a JDK with Project Valhalla's value classes");
+        String input = """
+            value final public class PointValueClass {
+                final int x;
+                final int y;
+
+                PointValueClass(int x, int y) {
+                    this.x = x;
+                    this.y = y;
+                }
+            }
+
+            value public record PointValueRecord(int x, int y) {}
+            """;
+        String expected = """
+            public final value class PointValueClass {
+                final int x;
+                final int y;
+
+                PointValueClass(int x, int y) {
+                    this.x = x;
+                    this.y = y;
+                }
+            }
+
+            public value record PointValueRecord(int x, int y) {}
+            """;
+        Formatter formatter = Formatter.createFormatter(
+                JavaFormatterOptions.builder().style(Style.OJF).build());
+
+        assertThat(formatter.formatSource(input)).isEqualTo(expected);
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {"non", "sealed", "value"})
+    void contextualKeywordAsIdentifier(String name) throws FormatterException {
+        // `value`, `sealed` and `non-sealed` are modifiers only in front of a declaration that carries them. Anywhere
+        // else they are identifiers, and a lambda parameter is the one declaration that starts with its name.
+        String input = """
+            import java.util.Map;
+
+            class T {
+                private final int NAME;
+
+                T(int NAME) {
+                    this.NAME = NAME;
+                }
+
+                void f(Map<String, Integer> map) {
+                    map.forEach((key, NAME) -> System.err.println(key + NAME));
+                }
+            }
+            """.replace("NAME", name);
+        Formatter formatter = Formatter.createFormatter(
+                JavaFormatterOptions.builder().style(Style.OJF).build());
+
+        assertThat(formatter.formatSource(input)).isEqualTo(input);
+    }
 }
Original file line number	Diff line number	Diff line change
`@@ -19,6 +19,7 @@`
`19`	`19`	`import static com.google.common.base.Preconditions.checkState;`
`20`	`20`	`import static com.google.common.collect.Iterables.getLast;`
`21`	`21`
	`22`	`+import com.google.common.base.Enums;`
`22`	`23`	`import com.google.common.collect.ImmutableList;`
`23`	`24`	`import com.google.common.collect.Ordering;`
`24`	`25`	`import com.google.common.collect.Range;`
`@@ -201,7 +202,7 @@ private static Modifier asModifier(ImmutableList<Token> tokens) {`
`201`	`202`	`if (modifier == null) {`
`202`	`203`	`return null;`
`203`	`204`	`}`
`204`		`- return Modifier.valueOf("NON_" + modifier.name());`
	`205`	`+ return Enums.getIfPresent(Modifier.class, "NON_" + modifier.name()).orNull();`
`205`	`206`	`}`
`206`	`207`
`207`	`208`	`/**`
`@@ -254,6 +255,7 @@ private static Modifier asModifier(Token token) {`
`254`	`255`	`}`
`255`	`256`	`return switch (token.getTok().getText()) {`
`256`	`257`	`case "sealed" -> Modifier.valueOf("SEALED");`
	`258`	`+ case "value" -> Enums.getIfPresent(Modifier.class, "VALUE").orNull();`
`257`	`259`	`default -> null;`
`258`	`260`	`};`
`259`	`261`	`}`