src/java.base/share/classes/java/lang/Class.java

@@ -85,13 +85,10 @@
 import jdk.internal.vm.annotation.IntrinsicCandidate;
 import jdk.internal.vm.annotation.Stable;
 
+import sun.invoke.util.BytecodeDescriptor;
 import sun.invoke.util.Wrapper;
-import sun.reflect.generics.factory.CoreReflectionFactory;
-import sun.reflect.generics.factory.GenericsFactory;
-import sun.reflect.generics.repository.ClassRepository;
-import sun.reflect.generics.repository.MethodRepository;
-import sun.reflect.generics.repository.ConstructorRepository;
-import sun.reflect.generics.scope.ClassScope;
+import sun.reflect.generics.info.ClassGenericInfo;
+import sun.reflect.generics.info.GenericInfo;
 import sun.security.util.SecurityConstants;
 import sun.reflect.annotation.*;
 import sun.reflect.misc.ReflectUtil;
@@ -1134,9 +1131,9 @@ Object getClassData() {
      */
     @SuppressWarnings("unchecked")
     public TypeVariable<Class<T>>[] getTypeParameters() {
-        ClassRepository info = getGenericInfo();
+        var info = getGenericInfo();
         if (info != null)
-            return (TypeVariable<Class<T>>[])info.getTypeParameters();
+            return info.getTypeVariables();
         else
             return (TypeVariable<Class<T>>[])new TypeVariable<?>[0];
     }
@@ -1188,7 +1185,7 @@ public TypeVariable<Class<T>>[] getTypeParameters() {
      * @since 1.5
      */
     public Type getGenericSuperclass() {
-        ClassRepository info = getGenericInfo();
+        var info = getGenericInfo();
         if (info == null) {
             return getSuperclass();
         }
@@ -1381,7 +1378,7 @@ private Class<?>[] getInterfaces(boolean cloneArray) {
      * @since 1.5
      */
     public Type[] getGenericInterfaces() {
-        ClassRepository info = getGenericInfo();
+        var info = getGenericInfo();
         return (info == null) ?  getInterfaces() : info.getSuperInterfaces();
     }
 
@@ -1564,17 +1561,10 @@ public Method getEnclosingMethod() throws SecurityException {
             if (!enclosingInfo.isMethod())
                 return null;
 
-            MethodRepository typeInfo = MethodRepository.make(enclosingInfo.getDescriptor(),
-                                                              getFactory());
-            Class<?>   returnType       = toClass(typeInfo.getReturnType());
-            Type []    parameterTypes   = typeInfo.getParameterTypes();
-            Class<?>[] parameterClasses = new Class<?>[parameterTypes.length];
-
-            // Convert Types to Classes; returned types *should*
-            // be class objects since the methodDescriptor's used
-            // don't have generics information
-            for(int i = 0; i < parameterClasses.length; i++)
-                parameterClasses[i] = toClass(parameterTypes[i]);
+            // Descriptor already validated by VM
+            List<Class<?>> types = BytecodeDescriptor.parseMethod(enclosingInfo.getDescriptor(), getClassLoader());
+            Class<?>   returnType       = types.removeLast();
+            Class<?>[] parameterClasses   = types.toArray(GenericInfo.EMPTY_CLASS_ARRAY);
 
             // Perform access check
             final Class<?> enclosingCandidate = enclosingInfo.getEnclosingClass();
@@ -1720,16 +1710,10 @@ public Constructor<?> getEnclosingConstructor() throws SecurityException {
             if (!enclosingInfo.isConstructor())
                 return null;
 
-            ConstructorRepository typeInfo = ConstructorRepository.make(enclosingInfo.getDescriptor(),
-                                                                        getFactory());
-            Type []    parameterTypes   = typeInfo.getParameterTypes();
-            Class<?>[] parameterClasses = new Class<?>[parameterTypes.length];
-
-            // Convert Types to Classes; returned types *should*
-            // be class objects since the methodDescriptor's used
-            // don't have generics information
-            for(int i = 0; i < parameterClasses.length; i++)
-                parameterClasses[i] = toClass(parameterTypes[i]);
+            // Descriptor already validated by VM
+            List<Class<?>> types = BytecodeDescriptor.parseMethod(enclosingInfo.getDescriptor(), getClassLoader());
+            types.removeLast();
+            Class<?>[] parameterClasses = types.toArray(GenericInfo.EMPTY_CLASS_ARRAY);
 
             // Perform access check
             final Class<?> enclosingCandidate = enclosingInfo.getEnclosingClass();
@@ -3491,28 +3475,22 @@ private ReflectionData<T> newReflectionData(SoftReference<ReflectionData<T>> old
     private native String getGenericSignature0();
 
     // Generic info repository; lazily initialized
-    private transient volatile ClassRepository genericInfo;
-
-    // accessor for factory
-    private GenericsFactory getFactory() {
-        // create scope and factory
-        return CoreReflectionFactory.make(this, ClassScope.make(this));
-    }
+    private transient volatile @Stable ClassGenericInfo<T> genericInfo;
 
     // accessor for generic info repository;
     // generic info is lazily initialized
-    private ClassRepository getGenericInfo() {
-        ClassRepository genericInfo = this.genericInfo;
+    private ClassGenericInfo<T> getGenericInfo() {
+        var genericInfo = this.genericInfo;
         if (genericInfo == null) {
             String signature = getGenericSignature0();
             if (signature == null) {
-                genericInfo = ClassRepository.NONE;
+                genericInfo = ClassGenericInfo.dummy();
             } else {
-                genericInfo = ClassRepository.make(signature, getFactory());
+                genericInfo = new ClassGenericInfo<>(this, signature);
             }
             this.genericInfo = genericInfo;
         }
-        return (genericInfo != ClassRepository.NONE) ? genericInfo : null;
+        return (genericInfo != ClassGenericInfo.dummy()) ? genericInfo : null;
     }
 
     // Annotations handling

src/java.base/share/classes/java/lang/reflect/Constructor.java

@@ -34,11 +34,8 @@
 import jdk.internal.vm.annotation.Stable;
 import sun.reflect.annotation.TypeAnnotation;
 import sun.reflect.annotation.TypeAnnotationParser;
-import sun.reflect.generics.repository.ConstructorRepository;
-import sun.reflect.generics.repository.GenericDeclRepository;
-import sun.reflect.generics.factory.CoreReflectionFactory;
-import sun.reflect.generics.factory.GenericsFactory;
-import sun.reflect.generics.scope.ConstructorScope;
+import sun.reflect.generics.info.ExecutableGenericInfo;
+import sun.reflect.generics.info.GenericInfo;
 import java.lang.annotation.Annotation;
 import java.lang.annotation.AnnotationFormatError;
 import java.util.StringJoiner;
@@ -73,27 +70,20 @@ public final class Constructor<T> extends Executable {
     // Generics and annotations support
     private final transient String    signature;
     // generic info repository; lazily initialized
-    private transient volatile ConstructorRepository genericInfo;
+    private transient volatile ExecutableGenericInfo<Constructor<T>> genericInfo;
     private final byte[]              annotations;
     private final byte[]              parameterAnnotations;
 
     // Generics infrastructure
-    // Accessor for factory
-    private GenericsFactory getFactory() {
-        // create scope and factory
-        return CoreReflectionFactory.make(this, ConstructorScope.make(this));
-    }
 
     // Accessor for generic info repository
     @Override
-    ConstructorRepository getGenericInfo() {
+    ExecutableGenericInfo<Constructor<T>> getGenericInfo() {
         var genericInfo = this.genericInfo;
         // lazily initialize repository if necessary
         if (genericInfo == null) {
             // create and cache generic info repository
-            genericInfo =
-                ConstructorRepository.make(getSignature(),
-                                           getFactory());
+            genericInfo = new ExecutableGenericInfo<>(this, getSignature());
             this.genericInfo = genericInfo;
         }
         return genericInfo; //return cached repository
@@ -245,9 +235,9 @@ public int getModifiers() {
     @SuppressWarnings({"rawtypes", "unchecked"})
     public TypeVariable<Constructor<T>>[] getTypeParameters() {
       if (getSignature() != null) {
-        return (TypeVariable<Constructor<T>>[])getGenericInfo().getTypeParameters();
+        return getGenericInfo().getTypeVariables();
       } else
-          return (TypeVariable<Constructor<T>>[])GenericDeclRepository.EMPTY_TYPE_VARS;
+          return (TypeVariable<Constructor<T>>[]) GenericInfo.EMPTY_TYPE_VARS;
     }
 
 

src/java.base/share/classes/java/lang/reflect/Executable.java

@@ -39,8 +39,8 @@
 import sun.reflect.annotation.AnnotationSupport;
 import sun.reflect.annotation.TypeAnnotationParser;
 import sun.reflect.annotation.TypeAnnotation;
+import sun.reflect.generics.info.ExecutableGenericInfo;
 import sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl;
-import sun.reflect.generics.repository.ConstructorRepository;
 
 /**
  * A shared superclass for the common functionality of {@link Method}
@@ -67,7 +67,7 @@ public abstract sealed class Executable extends AccessibleObject
      */
     abstract boolean hasGenericInformation();
 
-    abstract ConstructorRepository getGenericInfo();
+    abstract ExecutableGenericInfo<?> getGenericInfo();
 
     boolean equalParamTypes(Class<?>[] params1, Class<?>[] params2) {
         /* Avoid unnecessary cloning */
@@ -331,7 +331,7 @@ public Set<AccessFlag> accessFlags() {
     @SuppressWarnings("doclint:reference") // cross-module links
     public Type[] getGenericParameterTypes() {
         if (hasGenericInformation())
-            return getGenericInfo().getParameterTypes();
+            return getGenericInfo().getParameters();
         else
             return getParameterTypes();
     }
@@ -533,7 +533,7 @@ byte[] getTypeAnnotationBytes() {
     public Type[] getGenericExceptionTypes() {
         Type[] result;
         if (hasGenericInformation() &&
-            ((result = getGenericInfo().getExceptionTypes()).length > 0))
+            ((result = getGenericInfo().getExceptions()).length > 0))
             return result;
         else
             return getExceptionTypes();

src/java.base/share/classes/java/lang/reflect/Field.java

@@ -31,10 +31,7 @@
 import jdk.internal.reflect.Reflection;
 import jdk.internal.vm.annotation.ForceInline;
 import jdk.internal.vm.annotation.Stable;
-import sun.reflect.generics.repository.FieldRepository;
-import sun.reflect.generics.factory.CoreReflectionFactory;
-import sun.reflect.generics.factory.GenericsFactory;
-import sun.reflect.generics.scope.ClassScope;
+import sun.reflect.generics.info.FieldGenericInfo;
 import java.lang.annotation.Annotation;
 import java.util.Map;
 import java.util.Set;
@@ -77,7 +74,7 @@ class Field extends AccessibleObject implements Member {
     // Generics and annotations support
     private final transient String    signature;
     // generic info repository; lazily initialized
-    private transient volatile FieldRepository genericInfo;
+    private transient volatile FieldGenericInfo genericInfo;
     private final byte[]              annotations;
     // Cached field accessor created without override
     @Stable
@@ -97,21 +94,13 @@ class Field extends AccessibleObject implements Member {
 
     private String getGenericSignature() {return signature;}
 
-    // Accessor for factory
-    private GenericsFactory getFactory() {
-        Class<?> c = getDeclaringClass();
-        // create scope and factory
-        return CoreReflectionFactory.make(c, ClassScope.make(c));
-    }
-
     // Accessor for generic info repository
-    private FieldRepository getGenericInfo() {
+    private FieldGenericInfo getGenericInfo() {
         var genericInfo = this.genericInfo;
         // lazily initialize repository if necessary
         if (genericInfo == null) {
             // create and cache generic info repository
-            genericInfo = FieldRepository.make(getGenericSignature(),
-                                               getFactory());
+            genericInfo = new FieldGenericInfo(getDeclaringClass(), getGenericSignature());
             this.genericInfo = genericInfo;
         }
         return genericInfo; //return cached repository
@@ -291,7 +280,7 @@ public Class<?> getType() {
      */
     public Type getGenericType() {
         if (getGenericSignature() != null)
-            return getGenericInfo().getGenericType();
+            return getGenericInfo().getType();
         else
             return getType();
     }

src/java.base/share/classes/java/lang/reflect/Method.java

@@ -36,11 +36,8 @@
 import jdk.internal.vm.annotation.Stable;
 import sun.reflect.annotation.ExceptionProxy;
 import sun.reflect.annotation.TypeNotPresentExceptionProxy;
-import sun.reflect.generics.repository.GenericDeclRepository;
-import sun.reflect.generics.repository.MethodRepository;
-import sun.reflect.generics.factory.CoreReflectionFactory;
-import sun.reflect.generics.factory.GenericsFactory;
-import sun.reflect.generics.scope.MethodScope;
+import sun.reflect.generics.info.ExecutableGenericInfo;
+import sun.reflect.generics.info.GenericInfo;
 import sun.reflect.annotation.AnnotationType;
 import sun.reflect.annotation.AnnotationParser;
 import java.lang.annotation.Annotation;
@@ -82,7 +79,7 @@ public final class Method extends Executable {
     // Generics and annotations support
     private final transient String    signature;
     // generic info repository; lazily initialized
-    private transient volatile MethodRepository genericInfo;
+    private transient volatile ExecutableGenericInfo<Method> genericInfo;
     private final byte[]              annotations;
     private final byte[]              parameterAnnotations;
     private final byte[]              annotationDefault;
@@ -99,21 +96,14 @@ public final class Method extends Executable {
     // Generics infrastructure
     private String getGenericSignature() {return signature;}
 
-    // Accessor for factory
-    private GenericsFactory getFactory() {
-        // create scope and factory
-        return CoreReflectionFactory.make(this, MethodScope.make(this));
-    }
-
     // Accessor for generic info repository
     @Override
-    MethodRepository getGenericInfo() {
+    ExecutableGenericInfo<Method> getGenericInfo() {
         var genericInfo = this.genericInfo;
         // lazily initialize repository if necessary
         if (genericInfo == null) {
             // create and cache generic info repository
-            genericInfo = MethodRepository.make(getGenericSignature(),
-                                                getFactory());
+            genericInfo = new ExecutableGenericInfo<>(this, getGenericSignature());
             this.genericInfo = genericInfo;
         }
         return genericInfo; //return cached repository
@@ -255,9 +245,9 @@ public int getModifiers() {
     @SuppressWarnings({"rawtypes", "unchecked"})
     public TypeVariable<Method>[] getTypeParameters() {
         if (getGenericSignature() != null)
-            return (TypeVariable<Method>[])getGenericInfo().getTypeParameters();
+            return getGenericInfo().getTypeVariables();
         else
-            return (TypeVariable<Method>[])GenericDeclRepository.EMPTY_TYPE_VARS;
+            return (TypeVariable<Method>[]) GenericInfo.EMPTY_TYPE_VARS;
     }
 
     /**
@@ -296,7 +286,7 @@ public Class<?> getReturnType() {
      */
     public Type getGenericReturnType() {
       if (getGenericSignature() != null) {
-        return getGenericInfo().getReturnType();
+        return getGenericInfo().getResult();
       } else { return getReturnType();}
     }