[code-reflection] RFR: Cleanup JavaType factories

[Maurizio Cimadamore]

On Thu, 2 May 2024 13:12:56 GMT, Maurizio Cimadamore <mcimadamore at openjdk.org> wrote:

> This PR is a biggie cleanup of the various `JavaType` classes.
> 
> Perhaps the biggest contribution of this PR is to cleanup the factories in `JavaType`. The new factories are as follows:
> * a factory to create a type from a `ClassDesc`
> * a factory to create a type from a `j.l.r.Type`
> * a couple of factories for creating parameterized types, which work on `JavaType` instances
> * a couple of factories for array types
> * a couple of factories for wildcard types
> * a factory for type variables
> 
> This resolves the non-orthogonality found in the current set of factories, where one can take a `JavaType` and can, simultaneously, parameterize it, and turn it into an array type. Now the factories for these two operations are distinct.
> 
> The new factories also clarify the relationship between `JavaType`, `ClassDesc` and `j.l.Type` - that is:
> 
> * a type can be built from a nominal descriptor, using `type(ClassDesc)`
> * a type can turned into a nominal descriptor, using `toNominalDescriptor()`
> * a type can be built from a reflective type mirror, using `type(Type)`
> * a type can turned into a nominal descriptor, using `resolve(Lookup)`
> 
> These operations are symmetric - that is, you can start from a reflective type mirror, build a `JavaType` form it, then resolve that into a `Type` and check that you get back where you started. I've enhanced `JavaTypeTest` to check round trip for both `ClassDesc` and `Type`.
> 
> Note that the `JavaType` can be associated with complex reflective mirrors, e.g. beyond just `Class<?>`. For this reason, existing uses of `JavaType::resolve` in `BytecodeGenerator` and `Interpreter` which were expecting to obtain a `Class` from a `resolve` call have been rewritten to use the idiom `type.erasure().resolve(...)`.
> 
> As part of this PR I've also added javadoc for all the methods/fields under the `JavaType` hierarchy that did not have one, and expanded existing docs.
> 
> I've added several tests to make sure that all the conversions work as expected, and I have verified the examples (by opening their files in the IDE and make sure there's no error, I did not build).

src/java.base/share/classes/java/lang/reflect/code/type/ArrayType.java line 59:

> 57:     // Copied code in jdk.compiler module throws UOE
> 58:     private static GenericArrayType makeReflectiveGenericArray(Type component) {
> 59: /*__throw new UnsupportedOperationException();__*/        return sun.reflect.generics.reflectiveObjects.GenericArrayTypeImpl.make(component);

Here and elsewhere I had to "hide" the dependency from the reflection mirror factories, as such dependencies are not exported to `jdk.compiler`.

src/java.base/share/classes/java/lang/reflect/code/type/ClassType.java line 69:

> 67:                 baseType :
> 68:                 makeReflectiveParameterizedType(baseType,
> 69:                         resolvedTypeArgs.toArray(new Type[0]), baseType.getDeclaringClass()); // @@@: generic owner is erased here

Note: a `ParameterizedType` has the ability to model a "generic owner type". E.g. in the case of:

Foo<String>.Bar<Integer>

We currently don't support enclosing types/instances, so it's ok to just use the declaring class of the current type (which will be likely `null`).

-------------

PR Review Comment: https://git.openjdk.org/babylon/pull/71#discussion_r1588038708
PR Review Comment: https://git.openjdk.org/babylon/pull/71#discussion_r1588037512