perf(java): comprehensive parser and import layout optimizations

rewrite-benchmarks/src/jmh/java/org/openrewrite/benchmarks/java/BuilderFactoryBenchmark.java

@@ -0,0 +1,57 @@
+/*
+ * 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.benchmarks.java;
+
+import org.openjdk.jmh.annotations.*;
+import org.openjdk.jmh.infra.Blackhole;
+import org.openjdk.jmh.runner.Runner;
+import org.openjdk.jmh.runner.RunnerException;
+import org.openjdk.jmh.runner.options.Options;
+import org.openjdk.jmh.runner.options.OptionsBuilder;
+import org.openrewrite.java.JavaParser;
+
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Microbenchmark for JavaParser.fromJavaVersion() builder factory.
+ * Measures the overhead of reflection vs MethodHandle invocation.
+ */
+@Fork(value = 2, warmups = 1)
+@Measurement(iterations = 5, time = 1)
+@Warmup(iterations = 3, time = 1)
+@BenchmarkMode(Mode.Throughput)
+@OutputTimeUnit(TimeUnit.MICROSECONDS)
+@State(Scope.Benchmark)
+public class BuilderFactoryBenchmark {
+
+    /**
+     * Measures the cost of repeatedly calling fromJavaVersion() to obtain
+     * a new builder instance. This exercises the cached supplier's invoke path.
+     */
+    @Benchmark
+    public void builderFactory(Blackhole bh) {
+        JavaParser.Builder<? extends JavaParser, ?> builder = JavaParser.fromJavaVersion();
+        bh.consume(builder);
+    }
+
+    public static void main(String[] args) throws RunnerException {
+        Options opt = new OptionsBuilder()
+                .include(BuilderFactoryBenchmark.class.getSimpleName())
+                .shouldFailOnError(true)
+                .build();
+        new Runner(opt).run();
+    }
+}

rewrite-benchmarks/src/jmh/java/org/openrewrite/benchmarks/java/JavaSourceSetBenchmark.java

@@ -29,10 +29,4 @@ public void setup() {
     public void jarIOBenchmark() {
         JavaSourceSet.build("main", classpath);
     }
-
-    @Benchmark
-    public void classgraphBenchmark() {
-        //noinspection deprecation
-        JavaSourceSet.build("main", classpath, new JavaTypeCache(), false);
-    }
 }

rewrite-java-11/src/main/java/org/openrewrite/java/isolated/ReloadableJava11Parser.java

@@ -380,6 +380,8 @@ public ReloadableJava11Parser build() {
 
     private static class ByteArrayCapableJavacFileManager extends JavacFileManager {
         private final List<PackageAwareJavaFileObject> classByteClasspath;
+        private final IdentityHashMap<JavaFileObject, String> inferBinaryNameCache = new IdentityHashMap<>();
+        private final HashMap<String, List<JavaFileObject>> listCache = new HashMap<>();
 
         public ByteArrayCapableJavacFileManager(Context context,
                                                 boolean register,
@@ -396,19 +398,52 @@ public String inferBinaryName(Location location, JavaFileObject file) {
             if (file instanceof PackageAwareJavaFileObject) {
                 return ((PackageAwareJavaFileObject) file).getClassName();
             }
-            return super.inferBinaryName(location, file);
+            String cached = inferBinaryNameCache.get(file);
+            if (cached != null) {
+                return cached;
+            }
+            String result = super.inferBinaryName(location, file);
+            if (result != null) {
+                inferBinaryNameCache.put(file, result);
+            }
+            return result;
+        }
+
+        @Override
+        public void flush() {
+            super.flush();
+            inferBinaryNameCache.clear();
+            listCache.clear();
+        }
+
+        @Override
+        public void setLocationFromPaths(Location location, Collection<? extends Path> paths) throws IOException {
+            super.setLocationFromPaths(location, paths);
+            inferBinaryNameCache.clear();
+            listCache.clear();
         }
 
         @Override
         public Iterable<JavaFileObject> list(Location location, String packageName, Set<JavaFileObject.Kind> kinds, boolean recurse) throws IOException {
+            String key = location.getName() + ':' + packageName + ':' + kinds + ':' + recurse;
+            List<JavaFileObject> cached = listCache.get(key);
+            if (cached != null) {
+                return cached;
+            }
+            List<JavaFileObject> result;
             if (StandardLocation.CLASS_PATH.equals(location)) {
                 Iterable<JavaFileObject> listed = super.list(location, packageName, kinds, recurse);
-                return Stream.concat(classByteClasspath.stream()
+                result = Stream.concat(classByteClasspath.stream()
                                 .filter(jfo -> jfo.getPackage().equals(packageName)),
                         StreamSupport.stream(listed.spliterator(), false)
                 ).collect(toList());
+            } else {
+                Iterable<JavaFileObject> listed = super.list(location, packageName, kinds, recurse);
+                result = listed instanceof List ? (List<JavaFileObject>) listed :
+                        StreamSupport.stream(listed.spliterator(), false).collect(toList());
             }
-            return super.list(location, packageName, kinds, recurse);
+            listCache.put(key, result);
+            return result;
         }
     }
 

rewrite-java-17/src/main/java/org/openrewrite/java/isolated/ReloadableJava17Parser.java

@@ -351,6 +351,10 @@ public ReloadableJava17Parser build() {
 
     private static class ByteArrayCapableJavacFileManager extends JavacFileManager {
         private final List<PackageAwareJavaFileObject> classByteClasspath;
+        private final IdentityHashMap<JavaFileObject, String> inferBinaryNameCache = new IdentityHashMap<>();
+        private final HashMap<ListCacheKey, List<JavaFileObject>> listCache = new HashMap<>();
+
+        private record ListCacheKey(Location location, String packageName, Set<JavaFileObject.Kind> kinds, boolean recurse) {}
 
         public ByteArrayCapableJavacFileManager(Context context,
                                                 boolean register,
@@ -367,20 +371,52 @@ public String inferBinaryName(Location location, JavaFileObject file) {
             if (file instanceof PackageAwareJavaFileObject) {
                 return ((PackageAwareJavaFileObject) file).getClassName();
             }
-            return super.inferBinaryName(location, file);
+            String cached = inferBinaryNameCache.get(file);
+            if (cached != null) {
+                return cached;
+            }
+            String result = super.inferBinaryName(location, file);
+            if (result != null) {
+                inferBinaryNameCache.put(file, result);
+            }
+            return result;
+        }
+
+        @Override
+        public void flush() {
+            super.flush();
+            inferBinaryNameCache.clear();
+            listCache.clear();
+        }
+
+        @Override
+        public void setLocationFromPaths(Location location, Collection<? extends Path> paths) throws IOException {
+            super.setLocationFromPaths(location, paths);
+            inferBinaryNameCache.clear();
+            listCache.clear();
         }
 
         @Override
         public Iterable<JavaFileObject> list(Location location, String packageName, Set<JavaFileObject.Kind> kinds, boolean recurse) throws IOException {
-            if (StandardLocation.CLASS_PATH.equals(location)) {
+            ListCacheKey key = new ListCacheKey(location, packageName, kinds, recurse);
+            List<JavaFileObject> cached = listCache.get(key);
+            if (cached != null) {
+                return cached;
+            }
+            List<JavaFileObject> result;
+            if (StandardLocation.CLASS_PATH.equals(location) && !classByteClasspath.isEmpty()) {
                 Iterable<JavaFileObject> listed = super.list(location, packageName, kinds, recurse);
-                return classByteClasspath.isEmpty() ? listed :
-                        Stream.concat(classByteClasspath.stream()
+                result = Stream.concat(classByteClasspath.stream()
                                         .filter(jfo -> jfo.getPackage().equals(packageName)),
                                 StreamSupport.stream(listed.spliterator(), false)
                         ).collect(toList());
+            } else {
+                Iterable<JavaFileObject> listed = super.list(location, packageName, kinds, recurse);
+                result = listed instanceof List ? (List<JavaFileObject>) listed :
+                        StreamSupport.stream(listed.spliterator(), false).collect(toList());
             }
-            return super.list(location, packageName, kinds, recurse);
+            listCache.put(key, result);
+            return result;
         }
     }
 

rewrite-java-21/src/main/java/org/openrewrite/java/isolated/ReloadableJava21Parser.java

@@ -351,6 +351,10 @@ public ReloadableJava21Parser build() {
 
     private static class ByteArrayCapableJavacFileManager extends JavacFileManager {
         private final List<PackageAwareJavaFileObject> classByteClasspath;
+        private final IdentityHashMap<JavaFileObject, String> inferBinaryNameCache = new IdentityHashMap<>();
+        private final HashMap<ListCacheKey, List<JavaFileObject>> listCache = new HashMap<>();
+
+        private record ListCacheKey(Location location, String packageName, Set<JavaFileObject.Kind> kinds, boolean recurse) {}
 
         public ByteArrayCapableJavacFileManager(Context context,
                                                 boolean register,
@@ -367,20 +371,52 @@ public String inferBinaryName(Location location, JavaFileObject file) {
             if (file instanceof PackageAwareJavaFileObject) {
                 return ((PackageAwareJavaFileObject) file).getClassName();
             }
-            return super.inferBinaryName(location, file);
+            String cached = inferBinaryNameCache.get(file);
+            if (cached != null) {
+                return cached;
+            }
+            String result = super.inferBinaryName(location, file);
+            if (result != null) {
+                inferBinaryNameCache.put(file, result);
+            }
+            return result;
+        }
+
+        @Override
+        public void flush() {
+            super.flush();
+            inferBinaryNameCache.clear();
+            listCache.clear();
+        }
+
+        @Override
+        public void setLocationFromPaths(Location location, Collection<? extends Path> paths) throws IOException {
+            super.setLocationFromPaths(location, paths);
+            inferBinaryNameCache.clear();
+            listCache.clear();
         }
 
         @Override
         public Iterable<JavaFileObject> list(Location location, String packageName, Set<JavaFileObject.Kind> kinds, boolean recurse) throws IOException {
-            if (StandardLocation.CLASS_PATH.equals(location)) {
+            ListCacheKey key = new ListCacheKey(location, packageName, kinds, recurse);
+            List<JavaFileObject> cached = listCache.get(key);
+            if (cached != null) {
+                return cached;
+            }
+            List<JavaFileObject> result;
+            if (StandardLocation.CLASS_PATH.equals(location) && !classByteClasspath.isEmpty()) {
                 Iterable<JavaFileObject> listed = super.list(location, packageName, kinds, recurse);
-                return classByteClasspath.isEmpty() ? listed :
-                        Stream.concat(classByteClasspath.stream()
+                result = Stream.concat(classByteClasspath.stream()
                                         .filter(jfo -> jfo.getPackage().equals(packageName)),
                                 StreamSupport.stream(listed.spliterator(), false)
                         ).collect(toList());
+            } else {
+                Iterable<JavaFileObject> listed = super.list(location, packageName, kinds, recurse);
+                result = listed instanceof List ? (List<JavaFileObject>) listed :
+                        StreamSupport.stream(listed.spliterator(), false).collect(toList());
             }
-            return super.list(location, packageName, kinds, recurse);
+            listCache.put(key, result);
+            return result;
         }
     }
 

rewrite-java-25/src/main/java/org/openrewrite/java/isolated/ReloadableJava25Parser.java

@@ -351,6 +351,10 @@ public ReloadableJava25Parser build() {
 
     private static class ByteArrayCapableJavacFileManager extends JavacFileManager {
         private final List<PackageAwareJavaFileObject> classByteClasspath;
+        private final IdentityHashMap<JavaFileObject, String> inferBinaryNameCache = new IdentityHashMap<>();
+        private final HashMap<ListCacheKey, List<JavaFileObject>> listCache = new HashMap<>();
+
+        private record ListCacheKey(Location location, String packageName, Set<JavaFileObject.Kind> kinds, boolean recurse) {}
 
         public ByteArrayCapableJavacFileManager(Context context,
                                                 boolean register,
@@ -367,20 +371,52 @@ public String inferBinaryName(Location location, JavaFileObject file) {
             if (file instanceof PackageAwareJavaFileObject) {
                 return ((PackageAwareJavaFileObject) file).getClassName();
             }
-            return super.inferBinaryName(location, file);
+            String cached = inferBinaryNameCache.get(file);
+            if (cached != null) {
+                return cached;
+            }
+            String result = super.inferBinaryName(location, file);
+            if (result != null) {
+                inferBinaryNameCache.put(file, result);
+            }
+            return result;
+        }
+
+        @Override
+        public void flush() {
+            super.flush();
+            inferBinaryNameCache.clear();
+            listCache.clear();
+        }
+
+        @Override
+        public void setLocationFromPaths(Location location, Collection<? extends Path> paths) throws IOException {
+            super.setLocationFromPaths(location, paths);
+            inferBinaryNameCache.clear();
+            listCache.clear();
         }
 
         @Override
         public Iterable<JavaFileObject> list(Location location, String packageName, Set<JavaFileObject.Kind> kinds, boolean recurse) throws IOException {
-            if (StandardLocation.CLASS_PATH.equals(location)) {
+            ListCacheKey key = new ListCacheKey(location, packageName, kinds, recurse);
+            List<JavaFileObject> cached = listCache.get(key);
+            if (cached != null) {
+                return cached;
+            }
+            List<JavaFileObject> result;
+            if (StandardLocation.CLASS_PATH.equals(location) && !classByteClasspath.isEmpty()) {
                 Iterable<JavaFileObject> listed = super.list(location, packageName, kinds, recurse);
-                return classByteClasspath.isEmpty() ? listed :
-                        Stream.concat(classByteClasspath.stream()
+                result = Stream.concat(classByteClasspath.stream()
                                         .filter(jfo -> jfo.getPackage().equals(packageName)),
                                 StreamSupport.stream(listed.spliterator(), false)
                         ).collect(toList());
+            } else {
+                Iterable<JavaFileObject> listed = super.list(location, packageName, kinds, recurse);
+                result = listed instanceof List ? (List<JavaFileObject>) listed :
+                        StreamSupport.stream(listed.spliterator(), false).collect(toList());
             }
-            return super.list(location, packageName, kinds, recurse);
+            listCache.put(key, result);
+            return result;
         }
     }