8304425: ClassHierarchyResolver from Reflection

Reviewed-by: asotona

Author: liach

src/java.base/share/classes/jdk/internal/classfile/ClassHierarchyResolver.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2022, 2023, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -26,12 +26,19 @@
 
 import java.io.InputStream;
 import java.lang.constant.ClassDesc;
+import java.lang.invoke.MethodHandles;
 import java.util.Collection;
+import java.util.HashMap;
 import java.util.Map;
 import java.util.function.Function;
-import jdk.internal.classfile.impl.Util;
+import java.util.function.Supplier;
 
 import jdk.internal.classfile.impl.ClassHierarchyImpl;
+import jdk.internal.classfile.impl.ClassHierarchyImpl.ClassLoadingClassHierarchyResolver;
+import jdk.internal.classfile.impl.ClassHierarchyImpl.StaticClassHierarchyResolver;
+import jdk.internal.classfile.impl.Util;
+
+import static java.lang.constant.ConstantDescs.CD_Object;
 
 /**
  * Provides class hierarchy information for generating correct stack maps
@@ -41,18 +48,14 @@
 public interface ClassHierarchyResolver {
 
     /**
-     * Default singleton instance of {@linkplain ClassHierarchyResolver}
-     * using {@link ClassLoader#getSystemResourceAsStream(String)}
-     * as the {@code ClassStreamResolver}
+     * Returns a default instance of {@linkplain ClassHierarchyResolver}
+     * that reads from system class loader with
+     * {@link ClassLoader#getSystemResourceAsStream(String)} and falls
+     * back to reflection if a class is not found.
      */
-    ClassHierarchyResolver DEFAULT_CLASS_HIERARCHY_RESOLVER
-            = new ClassHierarchyImpl.CachedClassHierarchyResolver(
-            new Function<ClassDesc, InputStream>() {
-                @Override
-                public InputStream apply(ClassDesc classDesc) {
-                    return ClassLoader.getSystemResourceAsStream(Util.toInternalName(classDesc) + ".class");
-                }
-            });
+    static ClassHierarchyResolver defaultResolver() {
+        return ClassHierarchyImpl.DEFAULT_RESOLVER;
+    }
 
     /**
      * {@return the {@link ClassHierarchyInfo} for a given class name, or null
@@ -61,6 +64,31 @@ public InputStream apply(ClassDesc classDesc) {
      */
     ClassHierarchyInfo getClassInfo(ClassDesc classDesc);
 
+    /**
+     * Information about a resolved class.
+     */
+    sealed interface ClassHierarchyInfo permits ClassHierarchyImpl.ClassHierarchyInfoImpl {
+
+        /**
+         * Indicates that a class is a declared class, with the specific given super class.
+         *
+         * @param superClass descriptor of the super class, may be {@code null}
+         * @return the info indicating the super class
+         */
+        static ClassHierarchyInfo ofClass(ClassDesc superClass) {
+            return new ClassHierarchyImpl.ClassHierarchyInfoImpl(superClass, false);
+        }
+
+        /**
+         * Indicates that a class is an interface.
+         *
+         * @return the info indicating an interface
+         */
+        static ClassHierarchyInfo ofInterface() {
+            return new ClassHierarchyImpl.ClassHierarchyInfoImpl(CD_Object, true);
+        }
+    }
+
     /**
      * Chains this {@linkplain ClassHierarchyResolver} with another to be
      * consulted if this resolver does not know about the specified class.
@@ -74,30 +102,73 @@ default ClassHierarchyResolver orElse(ClassHierarchyResolver other) {
             public ClassHierarchyInfo getClassInfo(ClassDesc classDesc) {
                 var chi = ClassHierarchyResolver.this.getClassInfo(classDesc);
                 if (chi == null)
-                    chi = other.getClassInfo(classDesc);
+                    return other.getClassInfo(classDesc);
                 return chi;
             }
         };
     }
 
     /**
-     * Information about a resolved class.
-     * @param thisClass descriptor of this class
-     * @param isInterface whether this class is an interface
-     * @param superClass descriptor of the superclass (not relevant for interfaces)
+     * Returns a ClassHierarchyResolver that caches class hierarchy information from this
+     * resolver. The returned resolver will not update if delegate resolver returns differently.
+     * The thread safety of the returned resolver depends on the thread safety of the map
+     * returned by the {@code cacheFactory}.
+     *
+     * @param cacheFactory the factory for the cache
+     * @return the ClassHierarchyResolver with caching
      */
-    public record ClassHierarchyInfo(ClassDesc thisClass, boolean isInterface, ClassDesc superClass) {
+    default ClassHierarchyResolver cached(Supplier<Map<ClassDesc, ClassHierarchyInfo>> cacheFactory) {
+        return new ClassHierarchyImpl.CachedClassHierarchyResolver(this, cacheFactory.get());
     }
 
     /**
-     * Returns a {@linkplain  ClassHierarchyResolver} that extracts class hierarchy
-     * information from classfiles located by a mapping function
+     * Returns a ClassHierarchyResolver that caches class hierarchy information from this
+     * resolver. The returned resolver will not update if delegate resolver returns differently.
+     * The returned resolver is not thread-safe.
+     * {@snippet file="PackageSnippets.java" region="lookup-class-hierarchy-resolver"}
+     *
+     * @return the ClassHierarchyResolver
+     */
+    default ClassHierarchyResolver cached() {
+        record Factory() implements Supplier<Map<ClassDesc, ClassHierarchyInfo>> {
+            // uses a record as we cannot declare a local class static
+            static final Factory INSTANCE = new Factory();
+
+            @Override
+            public Map<ClassDesc, ClassHierarchyInfo> get() {
+                return new HashMap<>();
+            }
+        }
+        return cached(Factory.INSTANCE);
+    }
+
+    /**
+     * Returns a {@linkplain ClassHierarchyResolver} that extracts class hierarchy
+     * information from classfiles located by a mapping function. The mapping function
+     * should return null if it cannot provide a mapping for a classfile. Any IOException
+     * from the provided input stream is rethrown as an UncheckedIOException.
      *
      * @param classStreamResolver maps class descriptors to classfile input streams
      * @return the {@linkplain ClassHierarchyResolver}
      */
-    public static ClassHierarchyResolver ofCached(Function<ClassDesc, InputStream> classStreamResolver) {
-        return new ClassHierarchyImpl.CachedClassHierarchyResolver(classStreamResolver);
+    static ClassHierarchyResolver ofResourceParsing(Function<ClassDesc, InputStream> classStreamResolver) {
+        return new ClassHierarchyImpl.ResourceParsingClassHierarchyResolver(classStreamResolver);
+    }
+
+    /**
+     * Returns a {@linkplain ClassHierarchyResolver} that extracts class hierarchy
+     * information from classfiles located by a class loader.
+     *
+     * @param loader the class loader, to find class files
+     * @return the {@linkplain ClassHierarchyResolver}
+     */
+    static ClassHierarchyResolver ofResourceParsing(ClassLoader loader) {
+        return ofResourceParsing(new Function<>() {
+            @Override
+            public InputStream apply(ClassDesc classDesc) {
+                return loader.getResourceAsStream(Util.toInternalName(classDesc) + ".class");
+            }
+        });
     }
 
     /**
@@ -108,8 +179,52 @@ public static ClassHierarchyResolver ofCached(Function<ClassDesc, InputStream> c
      * @param classToSuperClass a map from classes to their super classes
      * @return the {@linkplain ClassHierarchyResolver}
      */
-    public static ClassHierarchyResolver of(Collection<ClassDesc> interfaces,
+    static ClassHierarchyResolver of(Collection<ClassDesc> interfaces,
                                             Map<ClassDesc, ClassDesc> classToSuperClass) {
-        return new ClassHierarchyImpl.StaticClassHierarchyResolver(interfaces, classToSuperClass);
+        return new StaticClassHierarchyResolver(interfaces, classToSuperClass);
+    }
+
+    /**
+     * Returns a ClassHierarchyResolver that extracts class hierarchy information via
+     * the Reflection API with a {@linkplain ClassLoader}.
+     *
+     * @param loader the class loader
+     * @return the class hierarchy resolver
+     */
+    static ClassHierarchyResolver ofClassLoading(ClassLoader loader) {
+        return new ClassLoadingClassHierarchyResolver(new Function<>() {
+            @Override
+            public Class<?> apply(ClassDesc cd) {
+                try {
+                    return Class.forName(Util.toBinaryName(cd.descriptorString()), false, loader);
+                } catch (ClassNotFoundException ex) {
+                    return null;
+                }
+            }
+        });
+    }
+
+    /**
+     * Returns a ClassHierarchyResolver that extracts class hierarchy information via
+     * the Reflection API with a {@linkplain MethodHandles.Lookup Lookup}. If the class
+     * resolved is inaccessible to the given lookup, it throws {@link
+     * IllegalArgumentException} instead of returning {@code null}.
+     *
+     * @param lookup the lookup, must be able to access classes to resolve
+     * @return the class hierarchy resolver
+     */
+    static ClassHierarchyResolver ofClassLoading(MethodHandles.Lookup lookup) {
+        return new ClassLoadingClassHierarchyResolver(new Function<>() {
+            @Override
+            public Class<?> apply(ClassDesc cd) {
+                try {
+                    return cd.resolveConstantDesc(lookup);
+                } catch (IllegalAccessException ex) {
+                    throw new IllegalArgumentException(ex);
+                } catch (ReflectiveOperationException ex) {
+                    return null;
+                }
+            }
+        });
     }
 }