Fix test issues and rename to HeterCont

Author: minborg

…nal/access/StableComponentContainer.java …ernal/access/HeterogeneousContainer.javasrc/java.base/share/classes/jdk/internal/access/StableComponentContainer.java renamed to src/java.base/share/classes/jdk/internal/access/HeterogeneousContainer.java src/java.base/share/classes/jdk/internal/access/StableComponentContainer.java renamed to src/java.base/share/classes/jdk/internal/access/HeterogeneousContainer.java

@@ -1,6 +1,5 @@
 package jdk.internal.access;
 
-import java.util.Collection;
 import java.util.Objects;
 import java.util.Set;
 import java.util.function.Function;
@@ -20,15 +19,15 @@
  * @param <T> The common type of the components. The type can be {@linkplain Object} if
  *            there is no common super type for the components.
  */
-public sealed interface StableComponentContainer<T> permits StableComponentContainerImpl {
+public sealed interface HeterogeneousContainer<T> permits HeterogeneousContainerImpl {
 
     /**
      * {@return the associated component for the provided {@code type}}
      *
      * @param type to use as lookup
      * @param <C> component type
      * @throws IllegalArgumentException if the provided {@code type} was not specified
-     *         {@linkplain StableComponentContainer#of(Set) at construction}.
+     *         {@linkplain HeterogeneousContainer#of(Set) at construction}.
      */
     <C extends T> C get(Class<C> type);
 
@@ -41,7 +40,7 @@ public sealed interface StableComponentContainer<T> permits StableComponentConta
      *              (nullable)
      * @param <C> component type
      * @throws IllegalArgumentException if the provided {@code type} was not specified
-     *         {@linkplain StableComponentContainer#of(Set) at construction}.
+     *         {@linkplain HeterogeneousContainer#of(Set) at construction}.
      */
     <C extends T> C orElse(Class<C> type, C other);
 
@@ -51,7 +50,7 @@ public sealed interface StableComponentContainer<T> permits StableComponentConta
      *
      * @param type to use as lookup
      * @throws IllegalArgumentException if the provided {@code type} was not specified
-     *         {@linkplain StableComponentContainer#of(Set) at construction}.
+     *         {@linkplain HeterogeneousContainer#of(Set) at construction}.
      */
     boolean isInitialized(Class<? extends T> type);
 
@@ -60,7 +59,7 @@ public sealed interface StableComponentContainer<T> permits StableComponentConta
      *
      * @param type to use as lookup
      * @throws IllegalArgumentException if the provided {@code type} was not specified
-     *         {@linkplain StableComponentContainer#of(Set) at construction}.
+     *         {@linkplain HeterogeneousContainer#of(Set) at construction}.
      * @throws IllegalStateException if the provided {@code type} was already associated
      *         with a component
      */
@@ -101,7 +100,7 @@ public sealed interface StableComponentContainer<T> permits StableComponentConta
      * @return the current (existing or computed) component associated with
      *         the specified type
      * @throws IllegalArgumentException if the provided {@code type} was not specified
-     *         {@linkplain StableComponentContainer#of(Set) at construction}.
+     *         {@linkplain HeterogeneousContainer#of(Set) at construction}.
      */
     <C extends T> C computeIfAbsent(Class<C> type,
                                     Function<Class<C>, ? extends C> mappingFunction);
@@ -114,15 +113,15 @@ <C extends T> C computeIfAbsent(Class<C> type,
      * @param <T>   the common type of the components. The type can be {@linkplain Object}
      *              if there is no common super type for the components.
      */
-    static <T> StableComponentContainer<T> of(Set<Class<? extends T>> types) {
+    static <T> HeterogeneousContainer<T> of(Set<Class<? extends T>> types) {
         // TOC TOU protection and
         // implicit null check of `types` and explicit null check on all its elements
         final Object[] inputs = new Object[types.size()];
         int idx = 0;
         for (Object type : types) {
             inputs[idx++] = Objects.requireNonNull(type);
         }
-        return StableComponentContainerImpl.of(inputs);
+        return HeterogeneousContainerImpl.of(inputs);
     }
 
     /**
@@ -134,7 +133,7 @@ static <T> StableComponentContainer<T> of(Set<Class<? extends T>> types) {
      * @param <T>  the common type of the components. The type can be {@linkplain Object}
      *             if there is no common super type for the components.
      */
-    static <T> StableComponentContainer<T> of(Class<T> type) {
+    static <T> HeterogeneousContainer<T> of(Class<T> type) {
         // Implicit null check
         if (!type.isSealed()) {
             throw new IllegalArgumentException("The provided type must be sealed: " + type);

…access/StableComponentContainerImpl.java …l/access/HeterogeneousContainerImpl.javasrc/java.base/share/classes/jdk/internal/access/StableComponentContainerImpl.java renamed to src/java.base/share/classes/jdk/internal/access/HeterogeneousContainerImpl.java src/java.base/share/classes/jdk/internal/access/StableComponentContainerImpl.java renamed to src/java.base/share/classes/jdk/internal/access/HeterogeneousContainerImpl.java

@@ -10,7 +10,7 @@
 import java.util.function.Function;
 
 @AOTSafeClassInitializer
-record StableComponentContainerImpl<T>(@Stable Object[] table) implements StableComponentContainer<T> {
+record HeterogeneousContainerImpl<T>(@Stable Object[] table) implements HeterogeneousContainer<T> {
 
     private static final Unsafe UNSAFE = Unsafe.getUnsafe();
 
@@ -127,7 +127,7 @@ private static int availableIndex(int probe) {
         return -probe - 1;
     }
 
-    static <T> StableComponentContainer<T> of(Object[] inputs) {
+    static <T> HeterogeneousContainer<T> of(Object[] inputs) {
         // Prepopulate all the keys upfront
         final Object[] table = new Object[inputs.length << 2];
         for (Object type : inputs) {
@@ -136,7 +136,7 @@ static <T> StableComponentContainer<T> of(Object[] inputs) {
             final int keyIndex = availableIndex(probe);
             table[keyIndex] = type;
         }
-        return new StableComponentContainerImpl<>(table);
+        return new HeterogeneousContainerImpl<>(table);
     }
 
 }

src/java.base/share/classes/jdk/internal/access/SharedSecrets.java

@@ -25,15 +25,13 @@
 
 package jdk.internal.access;
 
-import jdk.internal.vm.annotation.AOTSafeClassInitializer;
 import jdk.internal.vm.annotation.DontInline;
 import jdk.internal.vm.annotation.ForceInline;
 import jdk.internal.vm.annotation.Stable;
 
 import javax.crypto.SealedObject;
 import javax.crypto.spec.SecretKeySpec;
 import java.io.ObjectInputFilter;
-import java.lang.constant.Constable;
 import java.lang.invoke.MethodHandles;
 import java.lang.module.ModuleDescriptor;
 import java.net.HttpCookie;
@@ -84,24 +82,24 @@ interface and provides the ability to call package-private methods
  * code that would lead to the initialization of such fields, or else the AOT
  * cache creation will fail.
  */
-@AOTSafeClassInitializer
 public final class SharedSecrets {
     private SharedSecrets() { }
 
     // Todo: Remove this field.
     @Stable private static JavaLangAccess javaLangAccess;
 
-    // Sentinel value signaling that no explicit class initialization should be performed
-    private static final String NO_INIT = "";
+    // Sentinel value signaling that no explicit class initialization should be performed.
+    // Must not be of type Class or String.
+    private static final Object NO_INIT = new Object();
 
     // This map is used to associate a certain Access interface to another class where
     // the implementation of said interface resides
-    private static final Map<Class<? extends Access>, Constable> IMPLEMENTATIONS = implementations();
+    private static final Map<Class<? extends Access>, Object> IMPLEMENTATIONS = implementations();
 
     // In order to avoid creating a circular dependency graph, we refrain from using
     // ImmutableCollections. This means we have to resort to mutating a map.
-    private static Map<Class<? extends Access>, Constable> implementations() {
-        final Map<Class<? extends Access>, Constable> map = new HashMap<>();
+    private static Map<Class<? extends Access>, Object> implementations() {
+        final Map<Class<? extends Access>, Object> map = new HashMap<>();
 
         map.put(JavaAWTFontAccess.class, NO_INIT);
         map.put(JavaBeansAccess.class, NO_INIT);
@@ -138,8 +136,8 @@ private static Map<Class<? extends Access>, Constable> implementations() {
         return Collections.unmodifiableMap(map);
     }
 
-    private static final StableComponentContainer<Access> COMPONENTS =
-            StableComponentContainer.of(IMPLEMENTATIONS.keySet());
+    private static final HeterogeneousContainer<Access> COMPONENTS =
+            HeterogeneousContainer.of(IMPLEMENTATIONS.keySet());
 
     @ForceInline
     public static <T extends Access> T get(Class<T> clazz) {
@@ -151,16 +149,17 @@ public static <T extends Access> T get(Class<T> clazz) {
 
     @DontInline
     private static <T extends Access> T getSlowPath(Class<T> clazz) {
-        final Constable implementation = IMPLEMENTATIONS.get(clazz);
+        final Object implementation = IMPLEMENTATIONS.get(clazz);
         // We can't use pattern matching here as that would trigger
         // classfile initialization
         if (implementation instanceof Class<?> c) {
             ensureClassInitialized(c);
-        } else if (implementation instanceof String s && !s.equals(NO_INIT)) {
+        } else if (implementation instanceof String s) {
             ensureClassInitialized(s);
         } else {
-            throw new InternalError("Should not reach here: " + implementation);
+            throw new InternalError("Should not reach here: " + clazz + " -> " + implementation);
         }
+
         // The component should now be initialized
         return COMPONENTS.get(clazz);
     }

test/jdk/java/io/Serializable/serialFilter/CheckArrayTest.java

@@ -97,7 +97,7 @@ public void subclassedOIS(String pattern, int arraySize, Object[] array) throws
             // Check the arraysize against the filter
             ObjectInputFilter filter = ObjectInputFilter.Config.createFilter(pattern);
             ois.setObjectInputFilter(filter);
-            SharedSecrets.getJavaObjectInputStreamAccess()
+            SharedSecrets.get(JavaObjectInputStreamAccess.class)
                     .checkArray(ois, array.getClass(), arraySize);
             Assert.assertTrue(array.length >= arraySize,
                     "Should have thrown InvalidClassException due to array size");

test/jdk/java/net/InetAddress/getOriginalHostName.java

@@ -36,7 +36,7 @@
 public class getOriginalHostName {
 
     private static final JavaNetInetAddressAccess jna =
-        SharedSecrets.getJavaNetInetAddressAccess();
+        SharedSecrets.get(JavaNetInetAddressAccess.class);
 
     public static void main(String[] args) throws Exception {
         final String HOST = "dummyserver.java.net";