Predicated reflection and JNI config for NI

Introducing predicates for reflection and JNI configuration. The predicate
can be only a type name. For example,
"predicate": {
  "whenTypeReachable": "org.graalvm.ReachableClass"
 },

will apply configuration only if "type org.graalvm.ReachableClass" is reachable.
The default predicate for every reflection entry is "java.lang.Object" and as
such it will not be printed.

The Native Image agent does not emit predicates, but will fuse predicates
accordingly. Instead all config of one type, the fusion will happen by
the predicate and the type.

Author: vjovanov

docs/reference-manual/native-image/Reflection.md

@@ -107,14 +107,15 @@ Here, `reflectconfig` is a JSON file in the following format (use `--expert-opti
       { "name" : "format", "parameterTypes" : ["java.lang.String", "java.lang.Object[]"] }
     ]
   },
-    {
-      "name" : "java.lang.String$CaseInsensitiveComparator",
-      "methods" : [
-        { "name" : "compare" }
-      ]
-    }
+  {
+    "name" : "java.lang.String$CaseInsensitiveComparator",
+    "methods" : [
+      { "name" : "compare" }
+    ]
+  }
 ]
 ```
+
 The native image builder generates reflection metadata for all classes, methods, and fields referenced in that file.
 The `allPublicConstructors`, `allDeclaredConstructors`, `allPublicMethods`, `allDeclaredMethods`, `allPublicFields`, `allDeclaredFields`, `allPublicClasses`, and `allDeclaredClasses` attributes can be used to automatically include an entire set of members of a class.
 
@@ -125,6 +126,28 @@ Code may also write non-static final fields like `String.value` in this example,
 More than one configuration can be used by specifying multiple paths for `ReflectionConfigurationFiles` and separating them with `,`.
 Also, `-H:ReflectionConfigurationResources` can be specified to load one or several configuration files from the native image build's class path, such as from a JAR file.
 
+### Predicated Configuration
+
+Each configuration entry is taken into account when a `predicate` is satisfied. The currently supported predicate is `whenTypeReachable` which enables the configuration entry when a provided type is reachable. For example, the reflectively access `sun.misc.Unsafe.theUnsafe` only when `io.netty.util.internal.PlatformDependent0` is used we write
+
+```json
+{
+  "predicate" : { "whenTypeReachable" : "io.netty.util.internal.PlatformDependent0" },
+  "name" : "sun.misc.Unsafe",
+  "fields" : [
+    { "name" : "theUnsafe" }
+  ]
+}
+```
+
+*Predicated configuration* is the *preferred* way to specify reflection configuration: Every reflective access must be done through some piece of code. If that code is not reachable it makes little sense to include the corresponding reflection entry. The consistant usage of `predicate` results in *smaller binaries* and *better build times* as the image builder can selectively include reflectivelly accessed code.
+
+If a `predicate` is omitted, the element is always included (i.e., Native Image will assume that the predicate is `java.lang.Object`). When the same predicate is used for two distinct elements in two configuration entries, both elements will be included when the predicate is satisfied. When the same configuration is predicated by two types, it is necessary to add two configuration entries (one for each predicate).
+
+When used with [assisted configuration](BuildConfiguration.md#assisted-configuration-of-native-image-builds), predicated entries of existing configuration will not be fused with collected entries. The collected entries will all have the default predicate `java.lang.Object` that will not be printed.
+
+### Confugration with Features
+
 Alternatively, a custom `Feature` implementation can register program elements before and during the analysis phase of the native image build using the `RuntimeReflection` class. For example:
 ```java
 class RuntimeReflectionRegistrationFeature implements Feature {

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

@@ -48,6 +48,7 @@
 import org.graalvm.nativeimage.ImageSingletons;
 import org.graalvm.nativeimage.Platform;
 import org.graalvm.nativeimage.Platforms;
+import org.graalvm.nativeimage.impl.ConfigurationPredicate;
 import org.graalvm.nativeimage.impl.RuntimeReflectionSupport;
 
 //Checkstyle: allow reflection
@@ -68,7 +69,7 @@ public final class RuntimeReflection {
      * @since 19.0
      */
     public static void register(Class<?>... classes) {
-        ImageSingletons.lookup(RuntimeReflectionSupport.class).register(classes);
+        ImageSingletons.lookup(RuntimeReflectionSupport.class).register(ConfigurationPredicate.DEFAULT_CONFIGURATION_PREDICATE, classes);
     }
 
     /**
@@ -79,7 +80,7 @@ public static void register(Class<?>... classes) {
      * @since 19.0
      */
     public static void register(Executable... methods) {
-        ImageSingletons.lookup(RuntimeReflectionSupport.class).register(methods);
+        ImageSingletons.lookup(RuntimeReflectionSupport.class).register(ConfigurationPredicate.DEFAULT_CONFIGURATION_PREDICATE, methods);
     }
 
     /**
@@ -90,7 +91,7 @@ public static void register(Executable... methods) {
      * @since 19.0
      */
     public static void register(Field... fields) {
-        ImageSingletons.lookup(RuntimeReflectionSupport.class).register(false, fields);
+        ImageSingletons.lookup(RuntimeReflectionSupport.class).register(ConfigurationPredicate.DEFAULT_CONFIGURATION_PREDICATE, false, fields);
     }
 
     /**

sdk/src/org.graalvm.nativeimage/src/org/graalvm/nativeimage/impl/ConfigurationPredicate.java

@@ -0,0 +1,81 @@
+/*
+ * Copyright (c) 2021, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * The Universal Permissive License (UPL), Version 1.0
+ *
+ * Subject to the condition set forth below, permission is hereby granted to any
+ * person obtaining a copy of this software, associated documentation and/or
+ * data (collectively the "Software"), free of charge and under any and all
+ * copyright rights in the Software, and any and all patent rights owned or
+ * freely licensable by each licensor hereunder covering either (i) the
+ * unmodified Software as contributed to or provided by such licensor, or (ii)
+ * the Larger Works (as defined below), to deal in both
+ *
+ * (a) the Software, and
+ *
+ * (b) any piece of software and/or hardware listed in the lrgrwrks.txt file if
+ * one is included with the Software each a "Larger Work" to which the Software
+ * is contributed by such licensors),
+ *
+ * without restriction, including without limitation the rights to copy, create
+ * derivative works of, display, perform, and distribute the Software and make,
+ * use, sell, offer for sale, import, export, have made, and have sold the
+ * Software and the Larger Work(s), and to sublicense the foregoing rights on
+ * either these or other terms.
+ *
+ * This license is subject to the following condition:
+ *
+ * The above copyright notice and either this complete permission notice or at a
+ * minimum a reference to the UPL must be included in all copies or substantial
+ * portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+package org.graalvm.nativeimage.impl;
+
+import java.util.Objects;
+
+public final class ConfigurationPredicate {
+    private final String typeReachability;
+    public static final ConfigurationPredicate DEFAULT_CONFIGURATION_PREDICATE = new ConfigurationPredicate(Object.class.getTypeName());
+
+    public static ConfigurationPredicate create(String typeReachability) {
+        if (DEFAULT_CONFIGURATION_PREDICATE.typeReachability.equals(typeReachability)) {
+            return DEFAULT_CONFIGURATION_PREDICATE;
+        }
+        return new ConfigurationPredicate(typeReachability);
+    }
+
+    private ConfigurationPredicate(String typeReachability) {
+        this.typeReachability = typeReachability;
+    }
+
+    public String getTypeReachability() {
+        return typeReachability;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        ConfigurationPredicate predicate = (ConfigurationPredicate) o;
+        return Objects.equals(typeReachability, predicate.typeReachability);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(typeReachability);
+    }
+
+}

sdk/src/org.graalvm.nativeimage/src/org/graalvm/nativeimage/impl/ReflectionRegistry.java

@@ -44,10 +44,10 @@
 import java.lang.reflect.Field;
 
 public interface ReflectionRegistry {
-    void register(Class<?>... classes);
+    void register(ConfigurationPredicate predicate, Class<?>... classes);
 
-    void register(Executable... methods);
+    void register(ConfigurationPredicate predicate, Executable... methods);
 
-    void register(boolean finalIsWritable, Field... fields);
+    void register(ConfigurationPredicate predicate, boolean finalIsWritable, Field... fields);
 
 }

substratevm/src/com.oracle.svm.configure.test/src/com/oracle/svm/configure/test/config/OmitPreviousConfigTests.java

@@ -35,6 +35,7 @@
 import java.util.function.Function;
 import java.util.function.Predicate;
 
+import org.graalvm.nativeimage.impl.ConfigurationPredicate;
 import org.junit.Assert;
 import org.junit.Test;
 
@@ -145,8 +146,8 @@ private static void doTestTypeConfig(TypeConfiguration typeConfig) {
     }
 
     private static void doTestExpectedMissingTypes(TypeConfiguration typeConfig) {
-        Assert.assertNull(typeConfig.get("FlagTestA"));
-        Assert.assertNull(typeConfig.get("FlagTestB"));
+        Assert.assertNull(typeConfig.get(ConfigurationPredicate.DEFAULT_CONFIGURATION_PREDICATE, "FlagTestA"));
+        Assert.assertNull(typeConfig.get(ConfigurationPredicate.DEFAULT_CONFIGURATION_PREDICATE, "FlagTestB"));
     }
 
     private static void doTestTypeFlags(TypeConfiguration typeConfig) {
@@ -199,7 +200,7 @@ private static void doTestSerializationConfig(SerializationConfiguration seriali
     }
 
     private static ConfigurationType getConfigTypeOrFail(TypeConfiguration typeConfig, String typeName) {
-        ConfigurationType type = typeConfig.get(typeName);
+        ConfigurationType type = typeConfig.get(ConfigurationPredicate.DEFAULT_CONFIGURATION_PREDICATE, typeName);
         Assert.assertNotNull(type);
         return type;
     }
@@ -261,7 +262,7 @@ Map<ConfigurationMethod, ConfigurationMemberKind> getMethodsMap(ConfigurationMem
     void populateConfig() {
         ConfigurationType oldType = new ConfigurationType(getTypeName());
         setFlags(oldType);
-        previousConfig.add(oldType);
+        previousConfig.add(ConfigurationPredicate.DEFAULT_CONFIGURATION_PREDICATE, oldType);
 
         ConfigurationType newType = new ConfigurationType(getTypeName());
         for (Map.Entry<ConfigurationMethod, ConfigurationMemberKind> methodEntry : methodsThatMustExist.entrySet()) {
@@ -270,7 +271,7 @@ void populateConfig() {
         for (Map.Entry<ConfigurationMethod, ConfigurationMemberKind> methodEntry : methodsThatMustNotExist.entrySet()) {
             newType.addMethod(methodEntry.getKey().getName(), methodEntry.getKey().getInternalSignature(), methodEntry.getValue());
         }
-        currentConfig.add(newType);
+        currentConfig.add(ConfigurationPredicate.DEFAULT_CONFIGURATION_PREDICATE, newType);
     }
 
     void setFlags(ConfigurationType config) {
@@ -294,7 +295,7 @@ String getTypeName() {
 
     void doTest() {
         String name = getTypeName();
-        ConfigurationType configurationType = currentConfig.get(name);
+        ConfigurationType configurationType = currentConfig.get(ConfigurationPredicate.DEFAULT_CONFIGURATION_PREDICATE, name);
         if (methodsThatMustExist.size() == 0) {
             Assert.assertNull("Generated configuration type " + name + " exists. Expected it to be cleared as it is empty.", configurationType);
         } else {

substratevm/src/com.oracle.svm.configure/src/com/oracle/svm/configure/config/ConfigurationType.java

@@ -316,7 +316,6 @@ public void setAllPublicConstructors() {
 
     @Override
     public void printJson(JsonWriter writer) throws IOException {
-        writer.append('{').indent().newline();
         writer.quote("name").append(':').quote(qualifiedJavaName);
         optionallyPrintJsonBoolean(writer, haveAllDeclaredFields(), "allDeclaredFields");
         optionallyPrintJsonBoolean(writer, haveAllPublicFields(), "allPublicFields");
@@ -337,8 +336,6 @@ public void printJson(JsonWriter writer) throws IOException {
                             Comparator.comparing(ConfigurationMethod::getName).thenComparing(Comparator.nullsFirst(Comparator.comparing(ConfigurationMethod::getInternalSignature))),
                             JsonPrintable::printJson);
         }
-        writer.unindent().newline();
-        writer.append('}');
     }
 
     private static void printField(Map.Entry<String, FieldInfo> entry, JsonWriter w) throws IOException {

substratevm/src/com.oracle.svm.configure/src/com/oracle/svm/configure/config/ParserConfigurationAdapter.java

@@ -27,6 +27,7 @@
 import java.util.List;
 
 import com.oracle.svm.core.TypeResult;
+import org.graalvm.nativeimage.impl.ConfigurationPredicate;
 import com.oracle.svm.core.configure.ReflectionConfigurationParserDelegate;
 
 public class ParserConfigurationAdapter implements ReflectionConfigurationParserDelegate<ConfigurationType> {
@@ -38,81 +39,81 @@ public ParserConfigurationAdapter(TypeConfiguration configuration) {
     }
 
     @Override
-    public TypeResult<ConfigurationType> resolveTypeResult(String typeName) {
-        ConfigurationType type = configuration.get(typeName);
+    public TypeResult<ConfigurationType> resolveTypeResult(ConfigurationPredicate predicate, String typeName) {
+        ConfigurationType type = configuration.get(predicate, typeName);
         ConfigurationType result = type != null ? type : new ConfigurationType(typeName);
         return TypeResult.forType(typeName, result);
     }
 
     @Override
-    public void registerType(ConfigurationType type) {
-        configuration.add(type);
+    public void registerType(ConfigurationPredicate predicate, ConfigurationType type) {
+        configuration.add(predicate, type);
     }
 
     @Override
-    public void registerField(ConfigurationType type, String fieldName, boolean finalButWritable) {
+    public void registerField(ConfigurationPredicate predicate, ConfigurationType type, String fieldName, boolean finalButWritable) {
         type.addField(fieldName, ConfigurationMemberKind.PRESENT, finalButWritable);
     }
 
     @Override
-    public boolean registerAllMethodsWithName(ConfigurationType type, String methodName) {
+    public boolean registerAllMethodsWithName(ConfigurationPredicate predicate, ConfigurationType type, String methodName) {
         type.addMethodsWithName(methodName, ConfigurationMemberKind.PRESENT);
         return true;
     }
 
     @Override
-    public boolean registerAllConstructors(ConfigurationType type) {
+    public boolean registerAllConstructors(ConfigurationPredicate predicate, ConfigurationType type) {
         type.addMethodsWithName(ConfigurationMethod.CONSTRUCTOR_NAME, ConfigurationMemberKind.PRESENT);
         return true;
     }
 
     @Override
-    public void registerMethod(ConfigurationType type, String methodName, List<ConfigurationType> methodParameterTypes) {
+    public void registerMethod(ConfigurationPredicate predicate, ConfigurationType type, String methodName, List<ConfigurationType> methodParameterTypes) {
         type.addMethod(methodName, ConfigurationMethod.toInternalParamsSignature(methodParameterTypes), ConfigurationMemberKind.PRESENT);
     }
 
     @Override
-    public void registerConstructor(ConfigurationType type, List<ConfigurationType> methodParameterTypes) {
+    public void registerConstructor(ConfigurationPredicate predicate, ConfigurationType type, List<ConfigurationType> methodParameterTypes) {
         type.addMethod(ConfigurationMethod.CONSTRUCTOR_NAME, ConfigurationMethod.toInternalParamsSignature(methodParameterTypes), ConfigurationMemberKind.PRESENT);
     }
 
     @Override
-    public void registerPublicClasses(ConfigurationType type) {
+    public void registerPublicClasses(ConfigurationPredicate predicate, ConfigurationType type) {
         type.setAllPublicClasses();
     }
 
     @Override
-    public void registerDeclaredClasses(ConfigurationType type) {
+    public void registerDeclaredClasses(ConfigurationPredicate predicate, ConfigurationType type) {
         type.setAllDeclaredClasses();
     }
 
     @Override
-    public void registerPublicFields(ConfigurationType type) {
+    public void registerPublicFields(ConfigurationPredicate predicate, ConfigurationType type) {
         type.setAllPublicFields();
     }
 
     @Override
-    public void registerDeclaredFields(ConfigurationType type) {
+    public void registerDeclaredFields(ConfigurationPredicate predicate, ConfigurationType type) {
         type.setAllDeclaredFields();
     }
 
     @Override
-    public void registerPublicMethods(ConfigurationType type) {
+    public void registerPublicMethods(ConfigurationPredicate predicate, ConfigurationType type) {
         type.setAllPublicMethods();
     }
 
     @Override
-    public void registerDeclaredMethods(ConfigurationType type) {
+    public void registerDeclaredMethods(ConfigurationPredicate predicate, ConfigurationType type) {
         type.setAllDeclaredMethods();
     }
 
     @Override
-    public void registerPublicConstructors(ConfigurationType type) {
+    public void registerPublicConstructors(ConfigurationPredicate predicate, ConfigurationType type) {
         type.setAllPublicConstructors();
     }
 
     @Override
-    public void registerDeclaredConstructors(ConfigurationType type) {
+    public void registerDeclaredConstructors(ConfigurationPredicate predicate, ConfigurationType type) {
         type.setAllDeclaredConstructors();
     }