Add Java 26 early-access support via rewrite-java-next module

Adds a new rewrite-java-next module (copy of rewrite-java-25) to support Java 26 pre-release builds, enabling early validation of the OpenRewrite parser against upcoming JDK versions. Updates version detection cascade in JavaParser and CI workflows to include Java 26.

Author: timtebeek

.github/workflows/ci.yml

@@ -23,6 +23,7 @@ jobs:
     uses: openrewrite/gh-automation/.github/workflows/ci-gradle.yml@main
     with:
       java_version: |
+        26
         25
         21
     secrets:

.github/workflows/publish.yml

@@ -16,6 +16,7 @@ jobs:
     uses: openrewrite/gh-automation/.github/workflows/publish-gradle.yml@main
     with:
       java_version: |
+        26
         25
         21
     secrets:

rewrite-java-next/build.gradle.kts

@@ -0,0 +1,93 @@
+@file:Suppress("UnstableApiUsage")
+
+plugins {
+    id("org.openrewrite.build.language-library")
+    id("jvm-test-suite")
+}
+
+val javaTck = configurations.create("javaTck") {
+    isTransitive = false
+}
+
+dependencies {
+    api(project(":rewrite-core"))
+    api(project(":rewrite-java"))
+    implementation(project(":rewrite-java-lombok"))
+
+    compileOnly("org.slf4j:slf4j-api:1.7.+")
+
+    implementation("io.micrometer:micrometer-core:1.9.+")
+    implementation("io.github.classgraph:classgraph:latest.release")
+    implementation("org.ow2.asm:asm:latest.release")
+
+    testImplementation(project(":rewrite-test"))
+    testImplementation("org.antlr:antlr4-runtime:4.13.2")
+    "javaTck"(project(":rewrite-java-tck"))
+}
+
+java {
+    toolchain {
+        languageVersion.set(JavaLanguageVersion.of(26))
+    }
+}
+
+tasks.named("licenseFormat") { enabled = false }
+
+tasks.withType<JavaCompile>().configureEach {
+    sourceCompatibility = JavaVersion.VERSION_26.toString()
+    targetCompatibility = JavaVersion.VERSION_26.toString()
+
+    options.release.set(null as Int?) // remove `--release 8` set in `org.openrewrite.java-base`
+    options.compilerArgs.addAll(
+        listOf(
+            "--add-exports", "jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED",
+            "--add-exports", "jdk.compiler/com.sun.tools.javac.comp=ALL-UNNAMED",
+            "--add-exports", "jdk.compiler/com.sun.tools.javac.file=ALL-UNNAMED",
+            "--add-exports", "jdk.compiler/com.sun.tools.javac.main=ALL-UNNAMED",
+            "--add-exports", "jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED",
+            "--add-exports", "jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED"
+        )
+    )
+}
+
+//Javadoc compiler will complain about the use of the internal types.
+tasks.withType<Javadoc>().configureEach {
+    exclude(
+        "**/ReloadableJavaNextJavadocVisitor**",
+        "**/ReloadableJavaNextParser**",
+        "**/ReloadableJavaNextParserVisitor**",
+        "**/ReloadableJavaNextTypeMapping**",
+        "**/ReloadableJavaNextTypeSignatureBuilder**"
+    )
+}
+
+testing {
+    suites {
+        val test by getting(JvmTestSuite::class)
+
+        register("compatibilityTest", JvmTestSuite::class) {
+            dependencies {
+                implementation(project())
+                implementation(project(":rewrite-test"))
+                implementation(project(":rewrite-java-tck"))
+                implementation(project(":rewrite-java-test"))
+                implementation("org.assertj:assertj-core:latest.release")
+            }
+
+            targets {
+                all {
+                    testTask.configure {
+                        useJUnitPlatform()
+                        testClassesDirs += files(javaTck.files.map { zipTree(it) })
+                        jvmArgs = listOf("-XX:+UnlockDiagnosticVMOptions", "-XX:+ShowHiddenFrames")
+                        shouldRunAfter(test)
+                    }
+                }
+            }
+        }
+    }
+}
+
+tasks.named("check") {
+    dependsOn(testing.suites.named("compatibilityTest"))
+}

rewrite-java-next/src/main/java/org/openrewrite/java/JavaNextParser.java

@@ -0,0 +1,100 @@
+/*
+ * Copyright 2026 the original author or authors.
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * https://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.openrewrite.java;
+
+import org.jspecify.annotations.Nullable;
+import org.openrewrite.ExecutionContext;
+import org.openrewrite.SourceFile;
+import org.openrewrite.java.internal.JavaTypeCache;
+
+import java.lang.reflect.Constructor;
+import java.net.URI;
+import java.nio.charset.Charset;
+import java.nio.file.Path;
+import java.util.Collection;
+import java.util.stream.Stream;
+
+public class JavaNextParser implements JavaParser {
+    private final JavaParser delegate;
+
+    JavaNextParser(JavaParser delegate) {
+        this.delegate = delegate;
+    }
+
+    @Override
+    public Stream<SourceFile> parseInputs(Iterable<Input> sourceFiles, @Nullable Path relativeTo, ExecutionContext ctx) {
+        return delegate.parseInputs(sourceFiles, relativeTo, ctx);
+    }
+
+    @Override
+    public JavaParser reset() {
+        delegate.reset();
+        return this;
+    }
+
+    @Override
+    public JavaParser reset(Collection<URI> cus) {
+        delegate.reset(cus);
+        return this;
+    }
+
+    @Override
+    public void setClasspath(Collection<Path> classpath) {
+        delegate.setClasspath(classpath);
+    }
+
+    public static Builder builder() {
+        return new Builder();
+    }
+
+    public static class Builder extends JavaParser.Builder<JavaNextParser, Builder> {
+
+        @Nullable
+        private static ClassLoader moduleClassLoader;
+
+        static synchronized void lazyInitClassLoaders() {
+            if (moduleClassLoader != null) {
+                return;
+            }
+
+            ClassLoader appClassLoader = JavaNextParser.class.getClassLoader();
+            moduleClassLoader = new JavaUnrestrictedClassLoader(appClassLoader);
+        }
+
+        @Override
+        public JavaNextParser build() {
+            lazyInitClassLoaders();
+
+            try {
+                //Load the parser implementation use the unrestricted module classloader.
+                Class<?> parserImplementation = Class.forName("org.openrewrite.java.isolated.ReloadableJavaNextParser", true, moduleClassLoader);
+
+                Constructor<?> parserConstructor = parserImplementation
+                        .getDeclaredConstructor(Boolean.TYPE, Collection.class, Collection.class, Collection.class, Charset.class,
+                                Collection.class, JavaTypeCache.class);
+
+                parserConstructor.setAccessible(true);
+
+                JavaParser delegate = (JavaParser) parserConstructor
+                        .newInstance(logCompilationWarningsAndErrors, resolvedClasspath(), classBytesClasspath, dependsOn, charset, styles, javaTypeCache);
+
+                return new JavaNextParser(delegate);
+            } catch (Exception e) {
+                throw new IllegalStateException("Unable to construct JavaNextParser.", e);
+            }
+        }
+    }
+}