src/java.base/share/classes/sun/reflect/generics/repository/ClassRepository.java

*** 24,33 ****
--- 24,37 ----
   */
  
  package sun.reflect.generics.repository;
  
  import java.lang.reflect.Type;
+ import java.util.IdentityHashMap;
+ import java.util.Map;
+ import java.util.function.Function;
+ 
  import sun.reflect.generics.factory.GenericsFactory;
  import sun.reflect.generics.tree.ClassSignature;
  import sun.reflect.generics.tree.TypeTree;
  import sun.reflect.generics.visitor.Reifier;
  import sun.reflect.generics.parser.SignatureParser;
*** 96,105 ****
--- 100,133 ----
              superInterfaces = value;
          }
          return value.clone();
      }
  
+     private volatile Map<Object, Object> derivatives;
+     private static final Object nullDerivative = new Object();
+ 
+     public <D> D getDerivative(Class<?> clazz, Object key,
+                                Function<Class<?>, ? extends D> function) {
+         Map<Object, Object> dm = derivatives;
+         Object d = (dm == null) ? null : dm.get(key);
+         if (d == null) {
+             d = function.apply(clazz);
+             if (d == null) d = nullDerivative;
+             // re-read derivatives reference to minimize the chance of
+             // loosing concurrent updates...
+             dm = derivatives;
+             Map<Object, Object> newDm = new IdentityHashMap<>(
+                 (dm == null) ? 1 : dm.size() + 1);
+             newDm.put(key, d);
+             if (dm != null) newDm.putAll(dm);
+             derivatives = newDm;
+         }
+         @SuppressWarnings("unchecked")
+         D derivative = (d == nullDerivative) ? null : (D) d;
+         return derivative;
+     }
+ 
      private Type computeSuperclass() {
          Reifier r = getReifier(); // obtain visitor
          // Extract superclass subtree from AST and reify
          getTree().getSuperclass().accept(r);
          return r.getResult();