JavaTypeFactory: type construction, classpath fast paths, TypeTable JARs (#7528)

Surface area for parser-time type construction is now centralized on
JavaTypeFactory and threaded through every TypeMapping (Java 8/11/17/21/25,
Groovy, Kotlin/KotlinIr, Scala, JavaReflection). Each compute* method
returns the cached instance keyed by signature, or allocates a stub,
registers it, and runs the supplied initializer. Registering the stub
before the initializer runs is what makes recursive resolution safe —
a recursive lookup for the same signature finds the stub instead of
looping.

The previous two-phase create*/populate* surface is gone.
DefaultJavaTypeFactory implements compute* directly. Initializers call
unsafeSet on the stub to populate fields, replacing the earlier
typeFactory.populateXxx indirection.

JavaTypeFactory.Provider is the parser-builder hand-off: parsers
(JavaParser, Java*Parser, GroovyParser, KotlinParser, ScalaParser,
GradleParser) and JavaTemplateParser all consume a Provider rather than a
JavaTypeCache directly. JavaTypeCache itself is unchanged but the cache()
configuration on parser builders is deprecated in favor of typeFactory().
RecipeScheduler exposes a rootCursorProvider so a recipe-scoped
JavaTypeFactory can flow into JavaTemplate parses, keeping splice-time
type identity consistent with the surrounding LST.

JavaSourceSet gains two fast-path accessors for recipes that index by
classpath:

- findClasspathType(fqn) — sorted-bsearch on a per-source-set
  ClasspathIndex SPI, falls back to linear scan for legacy markers.
- classpathTypesInPackage(pkg) — sorted-prefix range scan.

Both go through ClasspathIndex.Subset, an SPI marker producers
(serializer V4 lazy backings) implement to short-circuit. ImportLayoutStyle
uses the per-package fast path. removeTypesMatching / removeTypesForGav
also dispatch through ClasspathIndex#withGavsRemoved when the marker
backing supports it, preserving lazy classpath views across recipe edits.

JavaSourceSetCompat retains the legacy materialization path under
@toBeRemoved(after = "2026-06-30") for recipes still calling
JavaSourceSet.build(...) directly. RecipeClassLoader parent-loads
JavaTypeFactory so recipe-side and parser-side factory instances unify.

TypeTable now writes per-artifact JARs (instead of classes-directories) so
javac uses ArchiveContainer with a cached central directory rather than
DirectoryContainer, which calls openat() per list() during template
parsing. Wall-mode profiling on AssertJ recipe / spring-data-commons:
__open worker samples 921 → 157 (-83%); recipe wall time 1m23s → 1m16s.
TypeTable annotations are now structured: AnnotationDeserializer is a
public class, TypeSignature parses ASM signatures, and TypeTableSink is
the abstract sink interface so writers don't go through string
round-trip.

Author: knutwannheden

docs/superpowers/plans/2026-03-20-csharp-parenthesization-utility.md

@@ -24,6 +24,7 @@
 import org.openrewrite.SourceFile;
 import org.openrewrite.internal.InMemoryLargeSourceSet;
 import org.openrewrite.java.JavaParser;
+import org.openrewrite.java.internal.DefaultJavaTypeFactory;
 import org.openrewrite.java.internal.JavaTypeCache;
 import org.xerial.snappy.Snappy;
 
@@ -103,7 +104,7 @@ public void setup() throws URISyntaxException {
 //                .logCompilationWarningsAndErrors(true)
 
         typeCache = new MapJavaTypeCache();
-        JavaParser parser = javaParser.typeCache(typeCache).build();
+        JavaParser parser = javaParser.typeFactory(new DefaultJavaTypeFactory(typeCache)).build();
         sourceFiles = parser
                 .parse(inputs, null, new InMemoryExecutionContext())
                 .collect(toList());

docs/superpowers/specs/2026-03-19-csharp-parenthesization-utility-design.md

@@ -24,6 +24,7 @@
 import org.openjdk.jmh.runner.options.OptionsBuilder;
 import org.openrewrite.InMemoryExecutionContext;
 import org.openrewrite.java.JavaParser;
+import org.openrewrite.java.internal.DefaultJavaTypeFactory;
 import org.openrewrite.java.internal.JavaTypeCache;
 
 import java.net.URISyntaxException;
@@ -40,7 +41,7 @@ public class JavaParserBenchmark {
     @Benchmark
     public void snappy(JavaCompilationUnitState state, Blackhole bh) {
         JavaTypeCache typeCache = new JavaCompilationUnitState.SnappyJavaTypeCache();
-        JavaParser parser = state.javaParser.typeCache(typeCache).build();
+        JavaParser parser = state.javaParser.typeFactory(new DefaultJavaTypeFactory(typeCache)).build();
         parser
                 .parse(state.inputs, null, new InMemoryExecutionContext())
                 .forEach(bh::consume);
@@ -49,7 +50,7 @@ public void snappy(JavaCompilationUnitState state, Blackhole bh) {
     @Benchmark
     public void adaptiveRadix(JavaCompilationUnitState state, Blackhole bh) {
         JavaTypeCache typeCache = new JavaTypeCache();
-        JavaParser parser = state.javaParser.typeCache(typeCache).build();
+        JavaParser parser = state.javaParser.typeFactory(new DefaultJavaTypeFactory(typeCache)).build();
         parser
                 .parse(state.inputs, null, new InMemoryExecutionContext())
                 .forEach(bh::consume);

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

@@ -22,16 +22,38 @@
 import org.openrewrite.table.SourcesFileErrors;
 import org.openrewrite.table.SourcesFileResults;
 
+import org.jspecify.annotations.Nullable;
+
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
+import java.util.function.Supplier;
 import java.util.stream.Stream;
 
 import static org.openrewrite.Recipe.PANIC;
 import static org.openrewrite.scheduling.WorkingDirectoryExecutionContextView.WORKING_DIRECTORY_ROOT;
 
 public class RecipeScheduler {
 
+    @Nullable
+    private Supplier<Cursor> rootCursorProvider;
+
+    /**
+     * Set a provider for the root cursor used in each recipe cycle.
+     * The provider is called once per cycle to create a fresh root cursor.
+     * This allows injecting shared state (e.g., a type cache provider) that will be
+     * visible to all visitors and template parsers during the cycle.
+     * <p>
+     * If not set, a default root cursor is created with {@code new Cursor(null, Cursor.ROOT_VALUE)}.
+     *
+     * @param provider supplies a configured root cursor for each cycle
+     * @return this scheduler for chaining
+     */
+    public RecipeScheduler rootCursorProvider(Supplier<Cursor> provider) {
+        this.rootCursorProvider = provider;
+        return this;
+    }
+
     public RecipeRun scheduleRun(Recipe recipe,
                                  LargeSourceSet sourceSet,
                                  ExecutionContext ctx,
@@ -70,7 +92,9 @@ private LargeSourceSet runRecipeCycles(Recipe recipe, LargeSourceSet sourceSet,
                 // this root cursor is shared by all `TreeVisitor` instances used created from `getVisitor` and
                 // single source applicable tests so that data can be shared at the root (especially for caching
                 // use cases like sharing a `JavaTypeCache` between `JavaTemplate` parsers).
-                Cursor rootCursor = new Cursor(null, Cursor.ROOT_VALUE);
+                Cursor rootCursor = rootCursorProvider != null
+                        ? rootCursorProvider.get()
+                        : new Cursor(null, Cursor.ROOT_VALUE);
                 try {
                     RecipeRunCycle<LargeSourceSet> cycle = createRecipeRunCycle(recipe, i, rootCursor, ctxWithWatch, recipeRunStats, searchResults, sourceFileResults, errorsTable);
                     ctxWithWatch.putCycle(cycle);

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

@@ -71,6 +71,10 @@ public class RecipeClassLoader extends URLClassLoader {
             "org.openrewrite.ipc.http.HttpSender",
             "org.openrewrite.java.JavadocVisitor",
             "org.openrewrite.java.internal.TypesInUse",
+            // Cursor-message wiring (TYPE_FACTORY_PROVIDER_KEY) passes a Provider
+            // implementation across the recipe/parent classloader boundary; the
+            // interface must be shared so the cast in JavaTemplateParser succeeds.
+            "org.openrewrite.java.internal.JavaTypeFactory",
             "org.openrewrite.maven.MavenDownloadingException",
             "org.openrewrite.maven.MavenDownloadingExceptions",
             "org.openrewrite.maven.MavenExecutionContextView",

rewrite-core/src/main/java/org/openrewrite/RecipeScheduler.java

@@ -24,6 +24,7 @@
 import org.openrewrite.groovy.GroovyParser;
 import org.openrewrite.groovy.tree.G;
 import org.openrewrite.java.JavaParser;
+import org.openrewrite.java.internal.JavaTypeFactory;
 import org.openrewrite.kotlin.KotlinParser;
 
 import java.nio.file.Path;
@@ -169,6 +170,16 @@ public Builder kotlinParser(KotlinParser.Builder kotlinParser) {
             return this;
         }
 
+        /**
+         * Forward a {@link JavaTypeFactory.Provider} to both the Groovy and Kotlin
+         * sub-parsers so either DSL variant produces types from the caller's factory.
+         */
+        public Builder typeFactoryProvider(JavaTypeFactory.Provider provider) {
+            this.groovyParser.typeFactoryProvider(provider);
+            this.kotlinParser.typeFactoryProvider(provider);
+            return this;
+        }
+
         public Builder buildscriptClasspath(Collection<Path> classpath) {
             this.buildscriptClasspath = classpath;
             return this;