src/java.base/share/classes/jdk/internal/reflect/Reflection.java

@@ -23,17 +23,16 @@
  * questions.
  */
 
 package jdk.internal.reflect;
 
-
 import java.lang.reflect.*;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Objects;
+import java.util.Set;
 import jdk.internal.HotSpotIntrinsicCandidate;
-import jdk.internal.loader.ClassLoaders;
 import jdk.internal.misc.VM;
 
 /** Common utility routines used by both java.lang and
     java.lang.reflect */
 

@@ -41,22 +40,27 @@
 
     /** Used to filter out fields and methods from certain classes from public
         view, where they are sensitive or they may contain VM-internal objects.
         These Maps are updated very rarely. Rather than synchronize on
         each access, we use copy-on-write */
-    private static volatile Map<Class<?>,String[]> fieldFilterMap;
-    private static volatile Map<Class<?>,String[]> methodFilterMap;
+    private static volatile Map<Class<?>, Set<String>> fieldFilterMap;
+    private static volatile Map<Class<?>, Set<String>> methodFilterMap;
+    private static final String WILDCARD = "*";
+    public static final Set<String> ALL_MEMBERS = Set.of(WILDCARD);
 
     static {
-        Map<Class<?>,String[]> map = new HashMap<Class<?>,String[]>();
-        map.put(Reflection.class,
-            new String[] {"fieldFilterMap", "methodFilterMap"});
-        map.put(System.class, new String[] {"security"});
-        map.put(Class.class, new String[] {"classLoader"});
-        fieldFilterMap = map;
-
-        methodFilterMap = new HashMap<>();
+        fieldFilterMap = Map.of(
+            Reflection.class, ALL_MEMBERS,
+            AccessibleObject.class, ALL_MEMBERS,
+            Class.class, Set.of("classLoader"),
+            ClassLoader.class, ALL_MEMBERS,
+            Constructor.class, ALL_MEMBERS,
+            Field.class, ALL_MEMBERS,
+            Method.class, ALL_MEMBERS,
+            System.class, Set.of("security")
+        );
+        methodFilterMap = Map.of();
     }
 
     /** Returns the class of the caller of the method calling this method,
         ignoring frames associated with java.lang.reflect.Method.invoke()
         and its implementation. */

@@ -234,35 +238,35 @@
         return false;
     }
 
     // fieldNames must contain only interned Strings
     public static synchronized void registerFieldsToFilter(Class<?> containingClass,
-                                              String ... fieldNames) {
+                                                           Set<String> fieldNames) {
         fieldFilterMap =
             registerFilter(fieldFilterMap, containingClass, fieldNames);
     }
 
     // methodNames must contain only interned Strings
     public static synchronized void registerMethodsToFilter(Class<?> containingClass,
-                                              String ... methodNames) {
+                                                            Set<String> methodNames) {
         methodFilterMap =
             registerFilter(methodFilterMap, containingClass, methodNames);
     }
 
-    private static Map<Class<?>,String[]> registerFilter(Map<Class<?>,String[]> map,
-            Class<?> containingClass, String ... names) {
+    private static Map<Class<?>, Set<String>> registerFilter(Map<Class<?>, Set<String>> map,
+                                                             Class<?> containingClass,
+                                                             Set<String> names) {
         if (map.get(containingClass) != null) {
             throw new IllegalArgumentException
                             ("Filter already registered: " + containingClass);
         }
-        map = new HashMap<Class<?>,String[]>(map);
-        map.put(containingClass, names);
+        map = new HashMap<>(map);
+        map.put(containingClass, Set.copyOf(names));
         return map;
     }
 
-    public static Field[] filterFields(Class<?> containingClass,
-                                       Field[] fields) {
+    public static Field[] filterFields(Class<?> containingClass, Field[] fields) {
         if (fieldFilterMap == null) {
             // Bootstrapping
             return fields;
         }
         return (Field[])filter(fields, fieldFilterMap.get(containingClass));

@@ -274,14 +278,17 @@
             return methods;
         }
         return (Method[])filter(methods, methodFilterMap.get(containingClass));
     }
 
-    private static Member[] filter(Member[] members, String[] filteredNames) {
+    private static Member[] filter(Member[] members, Set<String> filteredNames) {
         if ((filteredNames == null) || (members.length == 0)) {
             return members;
         }
+        if (filteredNames.contains(WILDCARD)) {
+            return (Member[]) Array.newInstance(members[0].getClass(), 0);
+        }
         int numNewMembers = 0;
         for (Member member : members) {
             boolean shouldSkip = false;
             for (String filteredName : filteredNames) {
                 if (member.getName() == filteredName) {