Ensure elements that should not be reflectively accessible are not constant folded in the ReflectionPlugins

Zeavee · Zeavee · commit 8faf4bb9fd5d · 2025-09-17T11:03:48.000+02:00
diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/RuntimeMetadataEncoderImpl.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/code/RuntimeMetadataEncoderImpl.java
@@ -405,11 +405,11 @@ private static Class<?>[] filterDeletedClasses(MetaAccessProvider metaAccess, Cl
         if (classes == null) {
             return null;
         }
-        AnalysisMetaAccess aMetaAccess = (AnalysisMetaAccess) ((HostedMetaAccess) metaAccess).getWrapped();
+        SubstitutionReflectivityFilter reflectivityFilter = SubstitutionReflectivityFilter.singleton();
         Set<Class<?>> reachableClasses = new HashSet<>();
         for (Class<?> clazz : classes) {
             try {
-                if (!SubstitutionReflectivityFilter.shouldExclude(clazz, aMetaAccess, aMetaAccess.getUniverse())) {
+                if (!reflectivityFilter.shouldExclude(clazz)) {
                     metaAccess.lookupJavaType(clazz);
                     reachableClasses.add(clazz);
                 }
diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/jni/JNIAccessFeature.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/jni/JNIAccessFeature.java
@@ -175,6 +175,8 @@ static final class JNICallableJavaMethod {
 
     private int loadedConfigurations;
 
+    private SubstitutionReflectivityFilter reflectivityFilter;
+
     private final Set<Class<?>> newClasses = Collections.newSetFromMap(new ConcurrentHashMap<>());
     private final Set<String> newNegativeClassLookups = Collections.newSetFromMap(new ConcurrentHashMap<>());
     private final Set<Executable> newMethods = Collections.newSetFromMap(new ConcurrentHashMap<>());
@@ -214,6 +216,8 @@ public void afterRegistration(AfterRegistrationAccess arg) {
                         access.getImageClassLoader());
         loadedConfigurations += ConfigurationParserUtils.parseAndRegisterConfigurations(legacyParser, access.getImageClassLoader(), "JNI",
                         ConfigurationFiles.Options.JNIConfigurationFiles, ConfigurationFiles.Options.JNIConfigurationResources, ConfigurationFile.JNI.getFileName());
+
+        reflectivityFilter = SubstitutionReflectivityFilter.singleton();
     }
 
     private final class JNIRuntimeAccessibilitySupportImpl extends ConditionalConfigurationRegistry
@@ -410,11 +414,11 @@ public void duringAnalysis(DuringAnalysisAccess a) {
         access.requireAnalysisIteration();
     }
 
-    private static JNIAccessibleClass addClass(Class<?> classObj, DuringAnalysisAccessImpl access) {
+    private JNIAccessibleClass addClass(Class<?> classObj, DuringAnalysisAccessImpl access) {
         if (classObj.isPrimitive()) {
             return null; // primitives cannot be looked up by name and have no methods or fields
         }
-        if (SubstitutionReflectivityFilter.shouldExclude(classObj, access.getMetaAccess(), access.getUniverse())) {
+        if (reflectivityFilter.shouldExclude(classObj)) {
             return null;
         }
         return JNIReflectionDictionary.currentLayer().addClassIfAbsent(classObj, c -> {
@@ -429,7 +433,7 @@ private static void addNegativeClassLookup(String className) {
     }
 
     public void addMethod(Executable method, DuringAnalysisAccessImpl access) {
-        if (SubstitutionReflectivityFilter.shouldExclude(method, access.getMetaAccess(), access.getUniverse())) {
+        if (reflectivityFilter.shouldExclude(method)) {
             return;
         }
         JNIAccessibleClass jniClass = addClass(method.getDeclaringClass(), access);
@@ -473,7 +477,7 @@ public void addMethod(Executable method, DuringAnalysisAccessImpl access) {
         });
     }
 
-    private static void addNegativeMethodLookup(Class<?> declaringClass, String methodName, Class<?>[] parameterTypes, DuringAnalysisAccessImpl access) {
+    private void addNegativeMethodLookup(Class<?> declaringClass, String methodName, Class<?>[] parameterTypes, DuringAnalysisAccessImpl access) {
         JNIAccessibleClass jniClass = addClass(declaringClass, access);
         JNIAccessibleMethodDescriptor descriptor = JNIAccessibleMethodDescriptor.of(methodName, parameterTypes);
         jniClass.addMethodIfAbsent(descriptor, d -> JNIAccessibleMethod.negativeMethodQuery(jniClass));
@@ -499,8 +503,8 @@ private JNIJavaCallVariantWrapperGroup createJavaCallVariantWrappers(DuringAnaly
         });
     }
 
-    private static void addField(Field reflField, boolean writable, DuringAnalysisAccessImpl access) {
-        if (SubstitutionReflectivityFilter.shouldExclude(reflField, access.getMetaAccess(), access.getUniverse())) {
+    private void addField(Field reflField, boolean writable, DuringAnalysisAccessImpl access) {
+        if (reflectivityFilter.shouldExclude(reflField)) {
             return;
         }
         JNIAccessibleClass jniClass = addClass(reflField.getDeclaringClass(), access);
@@ -525,7 +529,7 @@ private static void addField(Field reflField, boolean writable, DuringAnalysisAc
         bb.registerAsJNIAccessed(field, writable);
     }
 
-    private static void addNegativeFieldLookup(Class<?> declaringClass, String fieldName, DuringAnalysisAccessImpl access) {
+    private void addNegativeFieldLookup(Class<?> declaringClass, String fieldName, DuringAnalysisAccessImpl access) {
         JNIAccessibleClass jniClass = addClass(declaringClass, access);
         jniClass.addFieldIfAbsent(fieldName, d -> JNIAccessibleField.negativeFieldQuery(jniClass));
     }
diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/reflect/ReflectionDataBuilder.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/reflect/ReflectionDataBuilder.java
@@ -123,6 +123,7 @@ public class ReflectionDataBuilder extends ConditionalConfigurationRegistry impl
     private BeforeAnalysisAccessImpl analysisAccess;
     private final ClassForNameSupport classForNameSupport;
     private LayeredReflectionDataBuilder layeredReflectionDataBuilder;
+    private SubstitutionReflectivityFilter reflectivityFilter;
 
     // Reflection data
     private final Map<Class<?>, RecordComponent[]> registeredRecordComponents = new ConcurrentHashMap<>();
@@ -177,6 +178,7 @@ public void duringSetup(AnalysisMetaAccess analysisMetaAccess, AnalysisUniverse
         if (ImageLayerBuildingSupport.buildingImageLayer()) {
             layeredReflectionDataBuilder = LayeredReflectionDataBuilder.singleton();
         }
+        reflectivityFilter = SubstitutionReflectivityFilter.singleton();
     }
 
     public void beforeAnalysis(BeforeAnalysisAccessImpl beforeAnalysisAccess) {
@@ -438,7 +440,7 @@ private void registerMethods(ConfigurationCondition cnd, boolean queriedOnly, Ex
     }
 
     private void registerMethod(ConfigurationCondition cnd, boolean queriedOnly, Executable reflectExecutable) {
-        if (SubstitutionReflectivityFilter.shouldExclude(reflectExecutable, metaAccess, universe)) {
+        if (reflectivityFilter.shouldExclude(reflectExecutable)) {
             return;
         }
 
@@ -605,7 +607,7 @@ private void registerFields(ConfigurationCondition cnd, boolean queriedOnly, Fie
     }
 
     private void registerField(ConfigurationCondition cnd, boolean queriedOnly, Field reflectField) {
-        if (SubstitutionReflectivityFilter.shouldExclude(reflectField, metaAccess, universe)) {
+        if (reflectivityFilter.shouldExclude(reflectField)) {
             return;
         }
 
@@ -1056,7 +1058,7 @@ private boolean includeAnnotation(AnnotationValue annotationValue) {
             return false;
         }
         for (Class<?> type : annotationValue.getTypes()) {
-            if (type == null || SubstitutionReflectivityFilter.shouldExclude(type, metaAccess, universe)) {
+            if (type == null || reflectivityFilter.shouldExclude(type)) {
                 return false;
             }
         }
@@ -1097,7 +1099,7 @@ private boolean shouldExcludeClass(Class<?> clazz) {
         if (clazz.isPrimitive()) {
             return true; // primitives cannot be looked up by name and have no methods or fields
         }
-        return SubstitutionReflectivityFilter.shouldExclude(clazz, metaAccess, universe);
+        return reflectivityFilter.shouldExclude(clazz);
     }
 
     private static <T> T queryGenericInfo(Callable<T> callable) {
@@ -1131,7 +1133,7 @@ private void maybeRegisterRecordComponents(Class<?> clazz) {
             Method[] accessors = RecordUtils.getRecordComponentAccessorMethods(clazz);
             Set<Method> unregisteredAccessors = ConcurrentHashMap.newKeySet();
             for (Method accessor : accessors) {
-                if (SubstitutionReflectivityFilter.shouldExclude(accessor, metaAccess, universe)) {
+                if (reflectivityFilter.shouldExclude(accessor)) {
                     return;
                 }
                 unregisteredAccessors.add(accessor);
@@ -1241,7 +1243,7 @@ public void registerHeapDynamicHub(Object object, ScanReason reason) {
             if (isSealed()) {
                 throw new UnsupportedFeatureException("Registering new class for reflection when the image heap is already sealed: " + javaClass);
             }
-            if (!SubstitutionReflectivityFilter.shouldExclude(javaClass, metaAccess, universe)) {
+            if (!reflectivityFilter.shouldExclude(javaClass)) {
                 registerTypesForClass(metaAccess.lookupJavaType(javaClass), javaClass);
             }
         }
@@ -1260,7 +1262,7 @@ public void registerHeapReflectionField(Field reflectField, ScanReason reason) {
             if (isSealed()) {
                 throw new UnsupportedFeatureException("Registering new field for reflection when the image heap is already sealed: " + reflectField);
             }
-            if (!SubstitutionReflectivityFilter.shouldExclude(reflectField, metaAccess, universe)) {
+            if (!reflectivityFilter.shouldExclude(reflectField)) {
                 registerTypesForField(analysisField, reflectField, false);
                 if (analysisField.getDeclaringClass().isAnnotation()) {
                     processAnnotationField(ConfigurationCondition.alwaysTrue(), reflectField);
@@ -1285,7 +1287,7 @@ public void registerHeapReflectionExecutable(Executable reflectExecutable, ScanR
             if (isSealed()) {
                 throw new UnsupportedFeatureException("Registering new method for reflection when the image heap is already sealed: " + reflectExecutable);
             }
-            if (!SubstitutionReflectivityFilter.shouldExclude(reflectExecutable, metaAccess, universe)) {
+            if (!reflectivityFilter.shouldExclude(reflectExecutable)) {
                 registerTypesForMethod(analysisMethod, reflectExecutable);
                 if (reflectExecutable instanceof Method && reflectExecutable.getDeclaringClass().isAnnotation()) {
                     processAnnotationMethod(false, (Method) reflectExecutable);
diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/snippets/ReflectionPlugins.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/snippets/ReflectionPlugins.java
@@ -30,7 +30,6 @@
 import java.lang.invoke.VarHandle;
 import java.lang.reflect.AnnotatedElement;
 import java.lang.reflect.Constructor;
-import java.lang.reflect.Executable;
 import java.lang.reflect.Field;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
@@ -47,9 +46,6 @@
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
-import com.oracle.svm.core.TrackDynamicAccessEnabled;
-import com.oracle.svm.hosted.DynamicAccessDetectionFeature;
-import com.oracle.svm.hosted.NativeImageSystemClassLoader;
 import org.graalvm.nativeimage.ImageSingletons;
 import org.graalvm.nativeimage.hosted.RuntimeReflection;
 import org.graalvm.nativeimage.impl.RuntimeClassInitializationSupport;
@@ -58,22 +54,24 @@
 import com.oracle.graal.pointsto.meta.AnalysisUniverse;
 import com.oracle.svm.core.MissingRegistrationUtils;
 import com.oracle.svm.core.ParsingReason;
-import com.oracle.svm.core.annotate.Delete;
+import com.oracle.svm.core.TrackDynamicAccessEnabled;
 import com.oracle.svm.core.hub.ClassForNameSupport;
 import com.oracle.svm.core.hub.PredefinedClassesSupport;
 import com.oracle.svm.core.hub.RuntimeClassLoading;
 import com.oracle.svm.core.jdk.StackTraceUtils;
 import com.oracle.svm.core.option.HostedOptionKey;
 import com.oracle.svm.core.util.VMError;
+import com.oracle.svm.hosted.DynamicAccessDetectionFeature;
 import com.oracle.svm.hosted.ExceptionSynthesizer;
 import com.oracle.svm.hosted.FallbackFeature;
 import com.oracle.svm.hosted.ImageClassLoader;
+import com.oracle.svm.hosted.NativeImageSystemClassLoader;
 import com.oracle.svm.hosted.ReachabilityRegistrationNode;
 import com.oracle.svm.hosted.classinitialization.ClassInitializationSupport;
 import com.oracle.svm.hosted.dynamicaccessinference.DynamicAccessInferenceLog;
 import com.oracle.svm.hosted.dynamicaccessinference.StrictDynamicAccessInferenceFeature;
 import com.oracle.svm.hosted.substitute.AnnotationSubstitutionProcessor;
-import com.oracle.svm.hosted.substitute.DeletedElementException;
+import com.oracle.svm.hosted.substitute.SubstitutionReflectivityFilter;
 import com.oracle.svm.util.ModuleSupport;
 import com.oracle.svm.util.ReflectionUtil;
 import com.oracle.svm.util.TypeResult;
@@ -91,7 +89,6 @@
 import jdk.graal.compiler.options.Option;
 import jdk.vm.ci.meta.JavaConstant;
 import jdk.vm.ci.meta.JavaKind;
-import jdk.vm.ci.meta.MetaAccessProvider;
 import jdk.vm.ci.meta.ResolvedJavaField;
 import jdk.vm.ci.meta.ResolvedJavaMethod;
 import jdk.vm.ci.meta.ResolvedJavaType;
@@ -129,6 +126,7 @@ static class Options {
     private final boolean trackDynamicAccess;
     private final DynamicAccessDetectionFeature dynamicAccessDetectionFeature;
     private final DynamicAccessInferenceLog inferenceLog;
+    private final SubstitutionReflectivityFilter reflectivityFilter;
 
     private ReflectionPlugins(ImageClassLoader imageClassLoader, AnnotationSubstitutionProcessor annotationSubstitutions,
                     ClassInitializationPlugin classInitializationPlugin, AnalysisUniverse aUniverse, ParsingReason reason, FallbackFeature fallbackFeature) {
@@ -145,6 +143,8 @@ private ReflectionPlugins(ImageClassLoader imageClassLoader, AnnotationSubstitut
         this.classInitializationSupport = (ClassInitializationSupport) ImageSingletons.lookup(RuntimeClassInitializationSupport.class);
 
         this.inferenceLog = DynamicAccessInferenceLog.singletonOrNull();
+
+        this.reflectivityFilter = SubstitutionReflectivityFilter.singleton();
     }
 
     public static void registerInvocationPlugins(ImageClassLoader imageClassLoader, AnnotationSubstitutionProcessor annotationSubstitutions,
@@ -737,12 +737,12 @@ private static boolean isAllowedConstant(Class<?> clazz) {
      * compilation, not a lossy copy of it.
      */
     @SuppressWarnings("unchecked")
-    private <T> T getIntrinsic(GraphBuilderContext context, T element) {
+    private <T> T getIntrinsic(T element) {
         if (reason == ParsingReason.AutomaticUnsafeTransformation || reason == ParsingReason.EarlyClassInitializerAnalysis) {
             /* We are analyzing the static initializers and should always intrinsify. */
             return element;
         }
-        if (isDeleted(element, context.getMetaAccess())) {
+        if (element instanceof AnnotatedElement annotatedElement && reflectivityFilter.shouldExcludeElement(annotatedElement)) {
             /*
              * Should not intrinsify. Will fail during the reflective lookup at runtime. @Delete-ed
              * elements are ignored by the reflection plugins regardless of the value of
@@ -761,7 +761,7 @@ private JavaConstant getIntrinsicConstant(GraphBuilderContext context, Object el
             /* We are analyzing the static initializers and should always intrinsify. */
             return context.getSnippetReflection().forObject(element);
         }
-        if (isDeleted(element, context.getMetaAccess())) {
+        if (element instanceof AnnotatedElement annotatedElement && reflectivityFilter.shouldExcludeElement(annotatedElement)) {
             /*
              * Should not intrinsify. Will fail during the reflective lookup at runtime. @Delete-ed
              * elements are ignored by the reflection plugins regardless of the value of
@@ -772,31 +772,9 @@ private JavaConstant getIntrinsicConstant(GraphBuilderContext context, Object el
         return aUniverse.replaceObjectWithConstant(element, context.getSnippetReflection()::forObject);
     }
 
-    private static <T> boolean isDeleted(T element, MetaAccessProvider metaAccess) {
-        AnnotatedElement annotated = null;
-        try {
-            if (element instanceof Executable) {
-                annotated = metaAccess.lookupJavaMethod((Executable) element);
-            } else if (element instanceof Field) {
-                annotated = metaAccess.lookupJavaField((Field) element);
-            }
-        } catch (DeletedElementException ex) {
-            /*
-             * If ReportUnsupportedElementsAtRuntime is *not* set looking up a @Delete-ed element
-             * will result in a DeletedElementException.
-             */
-            return true;
-        }
-        /*
-         * If ReportUnsupportedElementsAtRuntime is set looking up a @Delete-ed element will return
-         * a substitution method that has the @Delete annotation.
-         */
-        return annotated != null && annotated.isAnnotationPresent(Delete.class);
-    }
-
     private JavaConstant pushConstant(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Object receiver, Object[] arguments, JavaKind returnKind, Object returnValue,
                     boolean allowNullReturnValue, boolean subjectToStrictDynamicAccessInference) {
-        Object intrinsicValue = getIntrinsic(b, returnValue == null && allowNullReturnValue ? NULL_MARKER : returnValue);
+        Object intrinsicValue = getIntrinsic(returnValue == null && allowNullReturnValue ? NULL_MARKER : returnValue);
         if (intrinsicValue == null) {
             return null;
         }
@@ -822,7 +800,7 @@ private boolean throwException(GraphBuilderContext b, ResolvedJavaMethod targetM
         if (exceptionMethod == null) {
             return false;
         }
-        Method intrinsic = getIntrinsic(b, exceptionMethod);
+        Method intrinsic = getIntrinsic(exceptionMethod);
         if (intrinsic == null) {
             return false;
         }
diff --git a/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/substitute/SubstitutionReflectivityFilter.java b/substratevm/src/com.oracle.svm.hosted/src/com/oracle/svm/hosted/substitute/SubstitutionReflectivityFilter.java
diff --git a/substratevm/src/com.oracle.svm.test/src/com/oracle/svm/test/ReflectionRegistrationTest.java b/substratevm/src/com.oracle.svm.test/src/com/oracle/svm/test/ReflectionRegistrationTest.java

Original file line number	Diff line number	Diff line change
`@@ -405,11 +405,11 @@ private static Class<?>[] filterDeletedClasses(MetaAccessProvider metaAccess, Cl`
`405`	`405`	`if (classes == null) {`
`406`	`406`	`return null;`
`407`	`407`	`}`
`408`		`- AnalysisMetaAccess aMetaAccess = (AnalysisMetaAccess) ((HostedMetaAccess) metaAccess).getWrapped();`
	`408`	`+ SubstitutionReflectivityFilter reflectivityFilter = SubstitutionReflectivityFilter.singleton();`
`409`	`409`	`Set<Class<?>> reachableClasses = new HashSet<>();`
`410`	`410`	`for (Class<?> clazz : classes) {`
`411`	`411`	`try {`
`412`		`- if (!SubstitutionReflectivityFilter.shouldExclude(clazz, aMetaAccess, aMetaAccess.getUniverse())) {`
	`412`	`+ if (!reflectivityFilter.shouldExclude(clazz)) {`
`413`	`413`	`metaAccess.lookupJavaType(clazz);`
`414`	`414`	`reachableClasses.add(clazz);`
`415`	`415`	`}`
Original file line number	Diff line number	Diff line change
`@@ -175,6 +175,8 @@ static final class JNICallableJavaMethod {`
`175`	`175`
`176`	`176`	`private int loadedConfigurations;`
`177`	`177`
	`178`	`+ private SubstitutionReflectivityFilter reflectivityFilter;`
	`179`	`+`
`178`	`180`	`private final Set<Class<?>> newClasses = Collections.newSetFromMap(new ConcurrentHashMap<>());`
`179`	`181`	`private final Set<String> newNegativeClassLookups = Collections.newSetFromMap(new ConcurrentHashMap<>());`
`180`	`182`	`private final Set<Executable> newMethods = Collections.newSetFromMap(new ConcurrentHashMap<>());`
`@@ -214,6 +216,8 @@ public void afterRegistration(AfterRegistrationAccess arg) {`
`214`	`216`	`access.getImageClassLoader());`
`215`	`217`	`loadedConfigurations += ConfigurationParserUtils.parseAndRegisterConfigurations(legacyParser, access.getImageClassLoader(), "JNI",`
`216`	`218`	`ConfigurationFiles.Options.JNIConfigurationFiles, ConfigurationFiles.Options.JNIConfigurationResources, ConfigurationFile.JNI.getFileName());`
	`219`	`+`
	`220`	`+ reflectivityFilter = SubstitutionReflectivityFilter.singleton();`
`217`	`221`	`}`
`218`	`222`
`219`	`223`	`private final class JNIRuntimeAccessibilitySupportImpl extends ConditionalConfigurationRegistry`
`@@ -410,11 +414,11 @@ public void duringAnalysis(DuringAnalysisAccess a) {`
`410`	`414`	`access.requireAnalysisIteration();`
`411`	`415`	`}`
`412`	`416`
`413`		`- private static JNIAccessibleClass addClass(Class<?> classObj, DuringAnalysisAccessImpl access) {`
	`417`	`+ private JNIAccessibleClass addClass(Class<?> classObj, DuringAnalysisAccessImpl access) {`
`414`	`418`	`if (classObj.isPrimitive()) {`
`415`	`419`	`return null; // primitives cannot be looked up by name and have no methods or fields`
`416`	`420`	`}`
`417`		`- if (SubstitutionReflectivityFilter.shouldExclude(classObj, access.getMetaAccess(), access.getUniverse())) {`
	`421`	`+ if (reflectivityFilter.shouldExclude(classObj)) {`
`418`	`422`	`return null;`
`419`	`423`	`}`
`420`	`424`	`return JNIReflectionDictionary.currentLayer().addClassIfAbsent(classObj, c -> {`
`@@ -429,7 +433,7 @@ private static void addNegativeClassLookup(String className) {`
`429`	`433`	`}`
`430`	`434`
`431`	`435`	`public void addMethod(Executable method, DuringAnalysisAccessImpl access) {`
`432`		`- if (SubstitutionReflectivityFilter.shouldExclude(method, access.getMetaAccess(), access.getUniverse())) {`
	`436`	`+ if (reflectivityFilter.shouldExclude(method)) {`
`433`	`437`	`return;`
`434`	`438`	`}`
`435`	`439`	`JNIAccessibleClass jniClass = addClass(method.getDeclaringClass(), access);`
`@@ -473,7 +477,7 @@ public void addMethod(Executable method, DuringAnalysisAccessImpl access) {`
`473`	`477`	`});`
`474`	`478`	`}`
`475`	`479`
`476`		`- private static void addNegativeMethodLookup(Class<?> declaringClass, String methodName, Class<?>[] parameterTypes, DuringAnalysisAccessImpl access) {`
	`480`	`+ private void addNegativeMethodLookup(Class<?> declaringClass, String methodName, Class<?>[] parameterTypes, DuringAnalysisAccessImpl access) {`
`477`	`481`	`JNIAccessibleClass jniClass = addClass(declaringClass, access);`
`478`	`482`	`JNIAccessibleMethodDescriptor descriptor = JNIAccessibleMethodDescriptor.of(methodName, parameterTypes);`
`479`	`483`	`jniClass.addMethodIfAbsent(descriptor, d -> JNIAccessibleMethod.negativeMethodQuery(jniClass));`
`@@ -499,8 +503,8 @@ private JNIJavaCallVariantWrapperGroup createJavaCallVariantWrappers(DuringAnaly`
`499`	`503`	`});`
`500`	`504`	`}`
`501`	`505`
`502`		`- private static void addField(Field reflField, boolean writable, DuringAnalysisAccessImpl access) {`
`503`		`- if (SubstitutionReflectivityFilter.shouldExclude(reflField, access.getMetaAccess(), access.getUniverse())) {`
	`506`	`+ private void addField(Field reflField, boolean writable, DuringAnalysisAccessImpl access) {`
	`507`	`+ if (reflectivityFilter.shouldExclude(reflField)) {`
`504`	`508`	`return;`
`505`	`509`	`}`
`506`	`510`	`JNIAccessibleClass jniClass = addClass(reflField.getDeclaringClass(), access);`
`@@ -525,7 +529,7 @@ private static void addField(Field reflField, boolean writable, DuringAnalysisAc`
`525`	`529`	`bb.registerAsJNIAccessed(field, writable);`
`526`	`530`	`}`
`527`	`531`
`528`		`- private static void addNegativeFieldLookup(Class<?> declaringClass, String fieldName, DuringAnalysisAccessImpl access) {`
	`532`	`+ private void addNegativeFieldLookup(Class<?> declaringClass, String fieldName, DuringAnalysisAccessImpl access) {`
`529`	`533`	`JNIAccessibleClass jniClass = addClass(declaringClass, access);`
`530`	`534`	`jniClass.addFieldIfAbsent(fieldName, d -> JNIAccessibleField.negativeFieldQuery(jniClass));`
`531`	`535`	`}`
Original file line number	Diff line number	Diff line change
`@@ -123,6 +123,7 @@ public class ReflectionDataBuilder extends ConditionalConfigurationRegistry impl`
`123`	`123`	`private BeforeAnalysisAccessImpl analysisAccess;`
`124`	`124`	`private final ClassForNameSupport classForNameSupport;`
`125`	`125`	`private LayeredReflectionDataBuilder layeredReflectionDataBuilder;`
	`126`	`+ private SubstitutionReflectivityFilter reflectivityFilter;`
`126`	`127`
`127`	`128`	`// Reflection data`
`128`	`129`	`private final Map<Class<?>, RecordComponent[]> registeredRecordComponents = new ConcurrentHashMap<>();`
`@@ -177,6 +178,7 @@ public void duringSetup(AnalysisMetaAccess analysisMetaAccess, AnalysisUniverse`
`177`	`178`	`if (ImageLayerBuildingSupport.buildingImageLayer()) {`
`178`	`179`	`layeredReflectionDataBuilder = LayeredReflectionDataBuilder.singleton();`
`179`	`180`	`}`
	`181`	`+ reflectivityFilter = SubstitutionReflectivityFilter.singleton();`
`180`	`182`	`}`
`181`	`183`
`182`	`184`	`public void beforeAnalysis(BeforeAnalysisAccessImpl beforeAnalysisAccess) {`
`@@ -438,7 +440,7 @@ private void registerMethods(ConfigurationCondition cnd, boolean queriedOnly, Ex`
`438`	`440`	`}`
`439`	`441`
`440`	`442`	`private void registerMethod(ConfigurationCondition cnd, boolean queriedOnly, Executable reflectExecutable) {`
`441`		`- if (SubstitutionReflectivityFilter.shouldExclude(reflectExecutable, metaAccess, universe)) {`
	`443`	`+ if (reflectivityFilter.shouldExclude(reflectExecutable)) {`
`442`	`444`	`return;`
`443`	`445`	`}`
`444`	`446`
`@@ -605,7 +607,7 @@ private void registerFields(ConfigurationCondition cnd, boolean queriedOnly, Fie`
`605`	`607`	`}`
`606`	`608`
`607`	`609`	`private void registerField(ConfigurationCondition cnd, boolean queriedOnly, Field reflectField) {`
`608`		`- if (SubstitutionReflectivityFilter.shouldExclude(reflectField, metaAccess, universe)) {`
	`610`	`+ if (reflectivityFilter.shouldExclude(reflectField)) {`
`609`	`611`	`return;`
`610`	`612`	`}`
`611`	`613`
`@@ -1056,7 +1058,7 @@ private boolean includeAnnotation(AnnotationValue annotationValue) {`
`1056`	`1058`	`return false;`
`1057`	`1059`	`}`
`1058`	`1060`	`for (Class<?> type : annotationValue.getTypes()) {`
`1059`		`- if (type == null \|\| SubstitutionReflectivityFilter.shouldExclude(type, metaAccess, universe)) {`
	`1061`	`+ if (type == null \|\| reflectivityFilter.shouldExclude(type)) {`
`1060`	`1062`	`return false;`
`1061`	`1063`	`}`
`1062`	`1064`	`}`
`@@ -1097,7 +1099,7 @@ private boolean shouldExcludeClass(Class<?> clazz) {`
`1097`	`1099`	`if (clazz.isPrimitive()) {`
`1098`	`1100`	`return true; // primitives cannot be looked up by name and have no methods or fields`
`1099`	`1101`	`}`
`1100`		`- return SubstitutionReflectivityFilter.shouldExclude(clazz, metaAccess, universe);`
	`1102`	`+ return reflectivityFilter.shouldExclude(clazz);`
`1101`	`1103`	`}`
`1102`	`1104`
`1103`	`1105`	`private static <T> T queryGenericInfo(Callable<T> callable) {`
`@@ -1131,7 +1133,7 @@ private void maybeRegisterRecordComponents(Class<?> clazz) {`
`1131`	`1133`	`Method[] accessors = RecordUtils.getRecordComponentAccessorMethods(clazz);`
`1132`	`1134`	`Set<Method> unregisteredAccessors = ConcurrentHashMap.newKeySet();`
`1133`	`1135`	`for (Method accessor : accessors) {`
`1134`		`- if (SubstitutionReflectivityFilter.shouldExclude(accessor, metaAccess, universe)) {`
	`1136`	`+ if (reflectivityFilter.shouldExclude(accessor)) {`
`1135`	`1137`	`return;`
`1136`	`1138`	`}`
`1137`	`1139`	`unregisteredAccessors.add(accessor);`
`@@ -1241,7 +1243,7 @@ public void registerHeapDynamicHub(Object object, ScanReason reason) {`
`1241`	`1243`	`if (isSealed()) {`
`1242`	`1244`	`throw new UnsupportedFeatureException("Registering new class for reflection when the image heap is already sealed: " + javaClass);`
`1243`	`1245`	`}`
`1244`		`- if (!SubstitutionReflectivityFilter.shouldExclude(javaClass, metaAccess, universe)) {`
	`1246`	`+ if (!reflectivityFilter.shouldExclude(javaClass)) {`
`1245`	`1247`	`registerTypesForClass(metaAccess.lookupJavaType(javaClass), javaClass);`
`1246`	`1248`	`}`
`1247`	`1249`	`}`
`@@ -1260,7 +1262,7 @@ public void registerHeapReflectionField(Field reflectField, ScanReason reason) {`
`1260`	`1262`	`if (isSealed()) {`
`1261`	`1263`	`throw new UnsupportedFeatureException("Registering new field for reflection when the image heap is already sealed: " + reflectField);`
`1262`	`1264`	`}`
`1263`		`- if (!SubstitutionReflectivityFilter.shouldExclude(reflectField, metaAccess, universe)) {`
	`1265`	`+ if (!reflectivityFilter.shouldExclude(reflectField)) {`
`1264`	`1266`	`registerTypesForField(analysisField, reflectField, false);`
`1265`	`1267`	`if (analysisField.getDeclaringClass().isAnnotation()) {`
`1266`	`1268`	`processAnnotationField(ConfigurationCondition.alwaysTrue(), reflectField);`
`@@ -1285,7 +1287,7 @@ public void registerHeapReflectionExecutable(Executable reflectExecutable, ScanR`
`1285`	`1287`	`if (isSealed()) {`
`1286`	`1288`	`throw new UnsupportedFeatureException("Registering new method for reflection when the image heap is already sealed: " + reflectExecutable);`
`1287`	`1289`	`}`
`1288`		`- if (!SubstitutionReflectivityFilter.shouldExclude(reflectExecutable, metaAccess, universe)) {`
	`1290`	`+ if (!reflectivityFilter.shouldExclude(reflectExecutable)) {`
`1289`	`1291`	`registerTypesForMethod(analysisMethod, reflectExecutable);`
`1290`	`1292`	`if (reflectExecutable instanceof Method && reflectExecutable.getDeclaringClass().isAnnotation()) {`
`1291`	`1293`	`processAnnotationMethod(false, (Method) reflectExecutable);`