Package org.openrewrite.java.internal

Interface JavaTypeFactory

All Known Implementing Classes:

DefaultJavaTypeFactory

@Incubating(since="8.82.0")
public interface JavaTypeFactory

Factory for constructing JavaType instances during parsing.

Two method families correspond to two construction shapes:

1. compute* — stub-then-initialize. The factory constructs a stub, registers it in the cache, then runs a Consumer that populates the stub via unsafeSet. Registering before the initializer runs is what makes recursive resolution during the initializer safe — reserved for types whose construction graph can recurse back to the same key:
   • computeClass(java.lang.String, long, org.openrewrite.java.tree.JavaType.FullyQualified.Kind, java.util.function.Consumer<org.openrewrite.java.tree.JavaType.Class>) — Java's class graph is mutually recursive (Foo extends Bar; Bar.field is Foo).
   • computeParameterized(java.lang.String, java.util.function.Consumer<org.openrewrite.java.tree.JavaType.Parameterized>) — F-bounded polymorphism (Comparable<T extends Comparable<T>>) and Kotlin parameterized self-refs.
   • computeGenericTypeVariable(java.lang.String, java.lang.String, org.openrewrite.java.tree.JavaType.GenericTypeVariable.Variance, java.util.function.Consumer<org.openrewrite.java.tree.JavaType.GenericTypeVariable>) — type variable bounds can reference the variable itself (<T extends Comparable<T>>).
2. *For — atomic build. The caller supplies a Supplier that returns a fully-constructed instance; the factory caches and returns it. No half-built object is ever observable through the cache. Used for variants without self-recursion on the same key: methodFor(java.lang.String, java.util.function.Supplier<org.openrewrite.java.tree.JavaType.Method>, java.util.function.Consumer<org.openrewrite.java.tree.JavaType.Method>), variableFor(java.lang.String, java.util.function.Supplier<org.openrewrite.java.tree.JavaType.Variable>), arrayFor(java.lang.String, java.util.function.Supplier<org.openrewrite.java.tree.JavaType.Array>), intersectionFor(java.lang.String, java.util.function.Supplier<org.openrewrite.java.tree.JavaType.Intersection>).

Parser code that needs a canonical identity-stable JavaType.Class for an FQN that has no Symbol/AST node (synthesized JVM facades, library placeholders, etc.) should call computeClass(java.lang.String, long, org.openrewrite.java.tree.JavaType.FullyQualified.Kind, java.util.function.Consumer<org.openrewrite.java.tree.JavaType.Class>) with an empty initializer. There is no separate "lookup" surface — the absence of richer attribution is signaled at the call site by an empty initializer.

Key formats

Two distinct keying schemes coexist; mixing them within one factory lifetime is a caller bug.

• FQN keys — computeClass(java.lang.String, long, org.openrewrite.java.tree.JavaType.FullyQualified.Kind, java.util.function.Consumer<org.openrewrite.java.tree.JavaType.Class>) is keyed on the fully-qualified name (e.g. java.util.List, com.acme.Outer$Inner for nested types). Universal across languages: every parser maps a JavaType.Class to its FQN the same way. The fqn value is exactly what JavaType.FullyQualified.getFullyQualifiedName() returns.
• Signature keys — every other compute* and *For method accepts an opaque signature string. The signature must uniquely identify the type within a single factory lifetime, and callers must obtain it from a JavaTypeSignatureBuilder consistent with the rest of the parser session. Different parsers produce different signature shapes (e.g. JvmsTypeSignatureBuilder for javac-driven Java parsing vs. per-language builders for Groovy/Kotlin/Scala/reflection); the factory does not inspect the format, but signatures from different builders are NOT interchangeable across one parser session's cache. The canonical reference shapes are documented on JavaTypeSignatureBuilder: e.g. methods com.MyThing{name=add,return=void,parameters=[Integer]}, variables com.MyThing{name=MY_FIELD}, generics Generic{U extends java.lang.Comparable}, parameterizeds java.util.List<java.util.List<Integer>>, arrays Integer[].

Method Summary

Modifier and Type	Method	Description
JavaType.Array	arrayFor(String signature, Supplier<JavaType.Array> builder)	Atomic build for JavaType.Array.
JavaType.Class	computeClass(String fqn, long flags, JavaType.FullyQualified.Kind kind, Consumer<JavaType.Class> initializer)	Cache-or-build for a fully-attributed JavaType.Class.
JavaType.GenericTypeVariable	computeGenericTypeVariable(String signature, String name, JavaType.GenericTypeVariable.Variance variance, Consumer<JavaType.GenericTypeVariable> initializer)	Cache-or-build for JavaType.GenericTypeVariable.
JavaType.Parameterized	computeParameterized(String signature, Consumer<JavaType.Parameterized> initializer)	Cache-or-build for JavaType.Parameterized.
JavaType.Intersection	intersectionFor(String signature, Supplier<JavaType.Intersection> builder)	Atomic build for JavaType.Intersection.
JavaType.Method	methodFor(String signature, Supplier<JavaType.Method> stub, Consumer<JavaType.Method> initializer)	Build for JavaType.Method with cycle-breaking on the same key.
JavaType.Variable	variableFor(String signature, Supplier<JavaType.Variable> builder)	Atomic build for JavaType.Variable.

Method Details

computeClass

JavaType.Class computeClass(String fqn,
 long flags,
 JavaType.FullyQualified.Kind kind,
 Consumer<JavaType.Class> initializer)

Cache-or-build for a fully-attributed JavaType.Class.

If a Class is already cached for fqn, the cached instance is returned and initializer does not run. Otherwise a stub is constructed with flags and kind populated, registered in the cache, and the initializer runs to populate the remaining fields (typically via JavaType.Class.unsafeSet(java.util.List<org.openrewrite.java.tree.JavaType>, org.openrewrite.java.tree.JavaType.FullyQualified, org.openrewrite.java.tree.JavaType.FullyQualified, java.util.List<org.openrewrite.java.tree.JavaType.FullyQualified>, java.util.List<org.openrewrite.java.tree.JavaType.FullyQualified>, java.util.List<org.openrewrite.java.tree.JavaType.Variable>, java.util.List<org.openrewrite.java.tree.JavaType.Method>)).

Parameters:

fqn - the fully-qualified name of the class, in the form JavaType.FullyQualified.getFullyQualifiedName() returns.

computeParameterized

JavaType.Parameterized computeParameterized(String signature,
 Consumer<JavaType.Parameterized> initializer)

Cache-or-build for JavaType.Parameterized. The initializer's recursive type(...) calls on type arguments can re-encounter the same signature (e.g. F-bounded polymorphism, Kotlin parameterized self-refs). The pre-registered stub lets those recursive lookups observe a usable partially-populated instance rather than re-entering the builder and looping. The initializer typically seeds the stub with its raw class via JavaType.Parameterized.unsafeSet(org.openrewrite.java.tree.JavaType.FullyQualified, java.util.List<org.openrewrite.java.tree.JavaType>) before resolving type arguments.

Parameters:

signature - an opaque per-factory key from JavaTypeSignatureBuilder.parameterizedSignature(java.lang.Object) — canonical shape java.util.List<java.util.List<Integer>>.

computeGenericTypeVariable

JavaType.GenericTypeVariable computeGenericTypeVariable(String signature,
 String name,
 JavaType.GenericTypeVariable.Variance variance,
 Consumer<JavaType.GenericTypeVariable> initializer)

Cache-or-build for JavaType.GenericTypeVariable. Type variable bounds can reference the variable itself — e.g. <T extends Comparable<T>> where T's upper bound is a JavaType.Parameterized that references T itself. Pre-registering the stub before the initializer runs makes the recursive lookup find the stub instead of looping.

Parameters:

signature - an opaque per-factory key from JavaTypeSignatureBuilder.genericSignature(java.lang.Object) — canonical shape Generic{U extends java.lang.Comparable} (covariant) or Generic{U super java.lang.Comparable} (contravariant).

methodFor

JavaType.Method methodFor(String signature,
 Supplier<JavaType.Method> stub,
 Consumer<JavaType.Method> initializer)

Build for JavaType.Method with cycle-breaking on the same key. Unlike variableFor(java.lang.String, java.util.function.Supplier<org.openrewrite.java.tree.JavaType.Variable>)/arrayFor(java.lang.String, java.util.function.Supplier<org.openrewrite.java.tree.JavaType.Array>)/intersectionFor(java.lang.String, java.util.function.Supplier<org.openrewrite.java.tree.JavaType.Intersection>), a method's attribution can recurse back to its own signature: an annotation-element method whose own annotations reference an annotation whose element is that same method (the Spring @AliasFor shape — value() is annotated @AliasFor, and @AliasFor's element is value()). So this mirrors computeClass(java.lang.String, long, org.openrewrite.java.tree.JavaType.FullyQualified.Kind, java.util.function.Consumer<org.openrewrite.java.tree.JavaType.Class>): stub constructs the bare instance from non-recursive header fields, which is cached before initializer runs the (possibly self-referential) attribution onto that same instance. A re-entrant lookup on the same signature then hits the cached stub instead of recursing — the signature and cache are the cycle-breaker, the same way they are for computeClass(java.lang.String, long, org.openrewrite.java.tree.JavaType.FullyQualified.Kind, java.util.function.Consumer<org.openrewrite.java.tree.JavaType.Class>).

Parameters:

signature - an opaque per-factory key from a JavaTypeSignatureBuilder — canonical shape com.MyThing{name=add,return=void,parameters=[Integer]}.

stub - constructs the bare method from non-recursive header fields (name, flags, parameter names, default value, declared formal type names); must not resolve any type that could recurse to this signature.

initializer - populates the cached stub's recursive attribution (declaring type, return type, parameter types, thrown exceptions, annotations) via unsafeSet.

variableFor

JavaType.Variable variableFor(String signature,
 Supplier<JavaType.Variable> builder)

Atomic build for JavaType.Variable.

Parameters:

signature - an opaque per-factory key from a JavaTypeSignatureBuilder — canonical shape com.MyThing{name=MY_FIELD}.

arrayFor

JavaType.Array arrayFor(String signature,
 Supplier<JavaType.Array> builder)

Atomic build for JavaType.Array.

Parameters:

signature - an opaque per-factory key from JavaTypeSignatureBuilder.arraySignature(java.lang.Object) — canonical shape Integer[].

intersectionFor

JavaType.Intersection intersectionFor(String signature,
 Supplier<JavaType.Intersection> builder)

Atomic build for JavaType.Intersection.

Parameters:

signature - an opaque per-factory key from a JavaTypeSignatureBuilder built from the intersection's component bounds.