DynamicAccess divided into two different API's, for resource registration and reflection registration.

Author: Mihailo Markovic

sdk/src/org.graalvm.nativeimage/src/org/graalvm/nativeimage/hosted/DynamicAccess.java

@@ -176,7 +176,9 @@ interface AfterRegistrationAccess extends FeatureAccess {
          * {@link Feature#afterRegistration}
          *
          */
-        DynamicAccess createDynamicAccess();
+        ReflectionDynamicAccess createReflectionDynamicAccess();
+
+        ResourceDynamicAccess createResourceDynamicAccess();
     }
 
     /**

sdk/src/org.graalvm.nativeimage/src/org/graalvm/nativeimage/hosted/Feature.java

@@ -44,29 +44,28 @@
 
 /**
  * Condition that needs to be satisfied for inclusion of elements for runtime access.
- * {@link InclusionCondition} is used with {@link DynamicAccess} for programmatic registration of
- * metadata.
+ * {@link InclusionCondition} is used with {@link ReflectionDynamicAccess} and
+ * {@link ResourceDynamicAccess} for programmatic registration of metadata.
  * <p>
- * Currently, there is only two types of condition:
+ * Currently, there is only two types of condition: typeReached and typeReachable(legacy)
  * <li><code>typeReached</code> (the default) that signifies that the type must be both reachable by
  * static analysis at build time, and reached at run time. A type is reached at run time, right
  * before the class-initialization routine starts for that type, or any of the type's subtypes are
  * reached.</li>
  * <p>
- *
  * User can only create <code>typeReached</code> conditions, since <code>typeReachable</code> are
- * deprecated. Conditions are created via {@link InclusionCondition#alwaysTrue} and
+ * deprecated. Conditions are created via {@link InclusionCondition#alwaysInclude} and
  * {@link InclusionCondition#typeReached} factory methods.
  */
 public interface InclusionCondition {
 
     /**
      * Creates the type-reached condition that is always satisfied. Any element that is predicated
      * with this condition will always be included.
-     * 
+     *
      * @return instance of the condition
      */
-    static InclusionCondition alwaysTrue() {
+    static InclusionCondition alwaysInclude() {
         return TypeCondition.JAVA_LANG_OBJECT_REACHED;
     }
 

sdk/src/org.graalvm.nativeimage/src/org/graalvm/nativeimage/hosted/InclusionCondition.java

@@ -0,0 +1,57 @@
+package org.graalvm.nativeimage.hosted;
+
+import java.lang.reflect.Executable;
+import java.lang.reflect.Field;
+
+/**
+ * This class is used to register classes, methods, fields for reflection, serialization and JNI
+ * access at runtime.
+ *
+ * It should only be used at {@link Feature#afterRegistration}.
+ */
+public interface ReflectionDynamicAccess {
+
+    /**
+     * Makes the provided classes available for reflection at runtime, and all of their accessible
+     * members available for reflection queries at run time. A call to {@link Class#forName} for the
+     * names of the classes will return the classes at run time.
+     *
+     * @param condition needs to be satisfied for inclusion of types for reflection at runtime
+     */
+    void register(InclusionCondition condition, Class<?>... classes);
+
+    /**
+     * Makes the provided class available for reflection at runtime if {@code condition} is
+     * satisfied. A call to {@link Class#forName} for the name of the class will return the class
+     * (if it exists) or a {@link ClassNotFoundException} at run time.
+     */
+    void registerClassLookup(InclusionCondition condition, String className);
+
+    /**
+     * Makes the provided methods available for reflection at runtime if {@code condition} is
+     * satisfied. The methods will be returned by {@link Class#getMethod},
+     * {@link Class#getDeclaredMethod(String, Class[])}, and all the other methods on {@link Class}
+     * that return a single method. Methods can be invoked via reflection.
+     */
+    void register(InclusionCondition condition, Executable... methods);
+
+    /**
+     * Makes the provided fields available for reflection at runtime if {@code condition} is
+     * satisfied.The fields will be returned by {@link Class#getField},
+     * {@link Class#getDeclaredField(String)}, and all the other methods on {@link Class} that
+     * return a single field. Fields can be accessed via reflection
+     */
+    void register(InclusionCondition condition, Field... fields);
+
+    /**
+     * Makes the provided classes available for serialization and reflection at runtime if
+     * {@code condition} is satisfied.
+     */
+    void registerForSerialization(InclusionCondition condition, Class<?>... classes);
+
+    /**
+     * Makes the provided classes available for JNI access at runtime if {@code condition} is
+     * satisfied.
+     */
+    void registerForJNIAccess(InclusionCondition condition, Class<?>... classes);
+}

sdk/src/org.graalvm.nativeimage/src/org/graalvm/nativeimage/hosted/ReflectionDynamicAccess.java

@@ -0,0 +1,33 @@
+package org.graalvm.nativeimage.hosted;
+
+/**
+ * This class is used to register Java resources and ResourceBundles that should be accessible at
+ * runtime.
+ */
+public interface ResourceDynamicAccess {
+
+    /**
+     * If {@code pattern} contains any wildcard patterns, such as star(*) or globstar(**), pattern
+     * is treated as glob pattern from {@code module} and will be registered if {@code condition} is
+     * satisfied. All resources that match the glob are available at runtime. Otherwise pattern
+     * represents Java resource from {@code module} that will be available at run time if
+     * {@code condition} is satisfied.
+     */
+    void register(InclusionCondition condition, Module module, String pattern);
+
+    default void register(InclusionCondition condition, String pattern) {
+        register(condition, null, pattern);
+    }
+
+    /**
+     * Make Java ResourceBundle that is specified by a {@code bundleName} from module {@code module}
+     * available at run time if {@code condition} is satisfied. If the given {@code module} is
+     * unnamed, the ResourceBundle is looked up on the classpath instead.
+     */
+    void registerResourceBundle(InclusionCondition condition, Module module, String bundleName);
+
+    default void registerResourceBundle(InclusionCondition condition, String bundleName) {
+        registerResourceBundle(condition, null, bundleName);
+    }
+
+}

sdk/src/org.graalvm.nativeimage/src/org/graalvm/nativeimage/hosted/ResourceDynamicAccess.java

@@ -67,7 +67,7 @@ public final class RuntimeForeignAccess {
      * @since 23.1
      */
     public static void registerForDowncall(Object desc, Object... options) {
-        ImageSingletons.lookup(RuntimeForeignAccessSupport.class).registerForDowncall(InclusionCondition.alwaysTrue(), desc, options);
+        ImageSingletons.lookup(RuntimeForeignAccessSupport.class).registerForDowncall(InclusionCondition.alwaysInclude(), desc, options);
     }
 
     /**
@@ -85,7 +85,7 @@ public static void registerForDowncall(Object desc, Object... options) {
      * @since 24.1
      */
     public static void registerForUpcall(Object desc, Object... options) {
-        ImageSingletons.lookup(RuntimeForeignAccessSupport.class).registerForUpcall(InclusionCondition.alwaysTrue(), desc, options);
+        ImageSingletons.lookup(RuntimeForeignAccessSupport.class).registerForUpcall(InclusionCondition.alwaysInclude(), desc, options);
     }
 
     /**
@@ -113,7 +113,7 @@ public static void registerForUpcall(Object desc, Object... options) {
      * @since 24.2
      */
     public static void registerForDirectUpcall(MethodHandle target, Object desc, Object... options) {
-        ImageSingletons.lookup(RuntimeForeignAccessSupport.class).registerForDirectUpcall(InclusionCondition.alwaysTrue(), target, desc, options);
+        ImageSingletons.lookup(RuntimeForeignAccessSupport.class).registerForDirectUpcall(InclusionCondition.alwaysInclude(), target, desc, options);
     }
 
     private RuntimeForeignAccess() {

sdk/src/org.graalvm.nativeimage/src/org/graalvm/nativeimage/hosted/RuntimeForeignAccess.java

@@ -65,7 +65,7 @@ public final class RuntimeJNIAccess {
      * @since 22.3
      */
     public static void register(Class<?>... classes) {
-        ImageSingletons.lookup(RuntimeJNIAccessSupport.class).register(InclusionCondition.alwaysTrue(), classes);
+        ImageSingletons.lookup(RuntimeJNIAccessSupport.class).register(InclusionCondition.alwaysInclude(), classes);
     }
 
     /**
@@ -78,7 +78,7 @@ public static void register(Class<?>... classes) {
      * @since 22.3
      */
     public static void register(Executable... methods) {
-        ImageSingletons.lookup(RuntimeJNIAccessSupport.class).register(InclusionCondition.alwaysTrue(), false, methods);
+        ImageSingletons.lookup(RuntimeJNIAccessSupport.class).register(InclusionCondition.alwaysInclude(), false, methods);
     }
 
     /**
@@ -91,7 +91,7 @@ public static void register(Executable... methods) {
      * @since 22.3
      */
     public static void register(Field... fields) {
-        ImageSingletons.lookup(RuntimeJNIAccessSupport.class).register(InclusionCondition.alwaysTrue(), false, fields);
+        ImageSingletons.lookup(RuntimeJNIAccessSupport.class).register(InclusionCondition.alwaysInclude(), false, fields);
     }
 
     private RuntimeJNIAccess() {

sdk/src/org.graalvm.nativeimage/src/org/graalvm/nativeimage/hosted/RuntimeJNIAccess.java

@@ -61,7 +61,7 @@ public final class RuntimeProxyCreation {
      * @since 22.3
      */
     public static void register(Class<?>... interfaces) {
-        ImageSingletons.lookup(RuntimeProxyCreationSupport.class).addProxyClass(InclusionCondition.alwaysTrue(), interfaces);
+        ImageSingletons.lookup(RuntimeProxyCreationSupport.class).addProxyClass(InclusionCondition.alwaysInclude(), interfaces);
     }
 
     private RuntimeProxyCreation() {