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
+
+With predicates, a class configuration entry is applied only if a provided `predicate` is satisfied. The only currently supported predicate is `whenTypeReachable`, which enables the configuration entry if the specified type is reachable through other code. For example, to support reflective access to `sun.misc.Unsafe.theUnsafe` only when `io.netty.util.internal.PlatformDependent0` is reachable, the configuration should look like:
+
+```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: if code doing a reflective access is not reachable, it is unnecessary to include its corresponding reflection entry. The consistent usage of `predicate` results in *smaller binaries* and *better build times* as the image builder can selectively include reflectively accessed code.
+
+If a `predicate` is omitted, the element is always included. 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 a configuration entry should be enabled if one of several types are reachable, it is necessary to add two configuration entries: one entry for each type predicate.
+
+When used with [assisted configuration](BuildConfiguration.md#assisted-configuration-of-native-image-builds), predicated entries of existing configuration will not be fused with agent-collected entries as agent-collected entries are not predicated.
+
+### Configuration 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.objectPredicate(), 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.objectPredicate(), 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.objectPredicate(), false, fields);
     }
 
     /**

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

@@ -0,0 +1,85 @@
+/*
+ * 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 typeName;
+    private static final ConfigurationPredicate OBJECT_PREDICATE = new ConfigurationPredicate(Object.class.getTypeName());
+
+    public static ConfigurationPredicate objectPredicate() {
+        return OBJECT_PREDICATE;
+    }
+
+    public static ConfigurationPredicate create(String typeReachability) {
+        if (OBJECT_PREDICATE.typeName.equals(typeReachability)) {
+            return OBJECT_PREDICATE;
+        }
+        return new ConfigurationPredicate(typeReachability);
+    }
+
+    private ConfigurationPredicate(String typeName) {
+        this.typeName = typeName;
+    }
+
+    public String getTypeName() {
+        return typeName;
+    }
+
+    @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(typeName, predicate.typeName);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(typeName);
+    }
+
+}

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.objectPredicate(), "FlagTestA"));
+        Assert.assertNull(typeConfig.get(ConfigurationPredicate.objectPredicate(), "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.objectPredicate(), typeName);
         Assert.assertNotNull(type);
         return type;
     }
@@ -259,11 +260,11 @@ Map<ConfigurationMethod, ConfigurationMemberKind> getMethodsMap(ConfigurationMem
     }
 
     void populateConfig() {
-        ConfigurationType oldType = new ConfigurationType(getTypeName());
+        ConfigurationType oldType = new ConfigurationType(ConfigurationPredicate.objectPredicate(), getTypeName());
         setFlags(oldType);
         previousConfig.add(oldType);
 
-        ConfigurationType newType = new ConfigurationType(getTypeName());
+        ConfigurationType newType = new ConfigurationType(ConfigurationPredicate.objectPredicate(), getTypeName());
         for (Map.Entry<ConfigurationMethod, ConfigurationMemberKind> methodEntry : methodsThatMustExist.entrySet()) {
             newType.addMethod(methodEntry.getKey().getName(), methodEntry.getKey().getInternalSignature(), methodEntry.getValue());
         }
@@ -294,7 +295,7 @@ String getTypeName() {
 
     void doTest() {
         String name = getTypeName();
-        ConfigurationType configurationType = currentConfig.get(name);
+        ConfigurationType configurationType = currentConfig.get(ConfigurationPredicate.objectPredicate(), 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/ConfigurationPredicatePrintable.java

@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2021, 2021, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package com.oracle.svm.configure.config;
+
+import java.io.IOException;
+
+import org.graalvm.nativeimage.impl.ConfigurationPredicate;
+
+import com.oracle.svm.configure.json.JsonWriter;
+
+public final class ConfigurationPredicatePrintable {
+    public static void printJson(ConfigurationPredicate predicate, JsonWriter writer) throws IOException {
+        if (!predicate.equals(ConfigurationPredicate.objectPredicate())) {
+            writer.append("\"predicate\":{");
+            writer.append("\"whenTypeReachable\":").quote(predicate.getTypeName());
+            writer.append("},").newline();
+        }
+    }
+}

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

@@ -31,11 +31,14 @@
 import java.util.function.BiPredicate;
 import java.util.function.Consumer;
 
+import org.graalvm.nativeimage.impl.ConfigurationPredicate;
+
 import com.oracle.svm.configure.json.JsonPrintable;
 import com.oracle.svm.configure.json.JsonPrinter;
 import com.oracle.svm.configure.json.JsonWriter;
 
 public class ConfigurationType implements JsonPrintable {
+    private final ConfigurationPredicate predicate;
     private final String qualifiedJavaName;
 
     private Map<String, FieldInfo> fields;
@@ -50,18 +53,21 @@ public class ConfigurationType implements JsonPrintable {
     private boolean allDeclaredConstructors;
     private boolean allPublicConstructors;
 
-    public ConfigurationType(String qualifiedJavaName) {
+    public ConfigurationType(ConfigurationPredicate predicate, String qualifiedJavaName) {
         assert qualifiedJavaName.indexOf('/') == -1 : "Requires qualified Java name, not internal representation";
         assert !qualifiedJavaName.startsWith("[") : "Requires Java source array syntax, for example java.lang.String[]";
+        this.predicate = predicate;
         this.qualifiedJavaName = qualifiedJavaName;
     }
 
     public ConfigurationType(ConfigurationType other) {
         qualifiedJavaName = other.qualifiedJavaName;
+        predicate = other.predicate;
         mergeWith(other);
     }
 
     public void mergeWith(ConfigurationType other) {
+        assert predicate.equals(other.predicate);
         assert qualifiedJavaName.equals(other.qualifiedJavaName);
         mergeFlagsWith(other);
         mergeFieldsWith(other);
@@ -134,6 +140,8 @@ private void maybeRemoveMethods(boolean hasAllDeclaredMethods, boolean hasAllPub
     }
 
     public void removeAll(ConfigurationType other) {
+        assert predicate.equals(other.predicate);
+        assert qualifiedJavaName.equals(other.qualifiedJavaName);
         removeFlags(other);
         removeFields(other);
         removeMethods(other);
@@ -317,6 +325,9 @@ public void setAllPublicConstructors() {
     @Override
     public void printJson(JsonWriter writer) throws IOException {
         writer.append('{').indent().newline();
+
+        ConfigurationPredicatePrintable.printJson(predicate, writer);
+
         writer.quote("name").append(':').quote(qualifiedJavaName);
         optionallyPrintJsonBoolean(writer, haveAllDeclaredFields(), "allDeclaredFields");
         optionallyPrintJsonBoolean(writer, haveAllPublicFields(), "allPublicFields");
@@ -337,8 +348,8 @@ 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('}');
+
+        writer.append('}').unindent().newline();
     }
 
     private static void printField(Map.Entry<String, FieldInfo> entry, JsonWriter w) throws IOException {
@@ -373,4 +384,8 @@ private static <T, S> Map<T, S> maybeRemove(Map<T, S> fromMap, Consumer<Map<T, S
         }
         return map;
     }
+
+    ConfigurationPredicate getPredicate() {
+        return predicate;
+    }
 }

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

@@ -26,21 +26,28 @@
 
 import java.util.List;
 
+import org.graalvm.nativeimage.impl.ConfigurationPredicate;
+
 import com.oracle.svm.core.TypeResult;
 import com.oracle.svm.core.configure.ReflectionConfigurationParserDelegate;
 
 public class ParserConfigurationAdapter implements ReflectionConfigurationParserDelegate<ConfigurationType> {
 
     private final TypeConfiguration configuration;
 
-    public ParserConfigurationAdapter(TypeConfiguration configuration) {
+    ParserConfigurationAdapter(TypeConfiguration configuration) {
         this.configuration = configuration;
     }
 
     @Override
-    public TypeResult<ConfigurationType> resolveTypeResult(String typeName) {
-        ConfigurationType type = configuration.get(typeName);
-        ConfigurationType result = type != null ? type : new ConfigurationType(typeName);
+    public TypeResult<ConfigurationPredicate> resolvePredicate(String typeName) {
+        return TypeResult.forType(typeName, ConfigurationPredicate.create(typeName));
+    }
+
+    @Override
+    public TypeResult<ConfigurationType> resolveType(ConfigurationPredicate predicate, String typeName) {
+        ConfigurationType type = configuration.get(predicate, typeName);
+        ConfigurationType result = type != null ? type : new ConfigurationType(predicate, typeName);
         return TypeResult.forType(typeName, result);
     }