src/java.base/share/classes/java/lang/invoke/LambdaMetafactory.java

@@ -28,10 +28,11 @@
  import java.io.Serializable;
  import java.util.Arrays;
  import java.lang.reflect.Array;
  import java.util.Objects;
  
+ import jdk.internal.access.JavaLangInvokeAccess.ReflectableLambdaInfo;
  import jdk.internal.vm.annotation.AOTSafeClassInitializer;
  
  /**
   * <p>Methods to facilitate the creation of simple "function objects" that
   * implement one or more interfaces by delegation to a provided {@link MethodHandle},

@@ -341,20 +342,32 @@
                                         MethodType factoryType,
                                         MethodType interfaceMethodType,
                                         MethodHandle implementation,
                                         MethodType dynamicMethodType)
              throws LambdaConversionException {
-         AbstractValidatingLambdaMetafactory mf;
-         mf = new InnerClassLambdaMetafactory(Objects.requireNonNull(caller),
-                                              Objects.requireNonNull(factoryType),
-                                              Objects.requireNonNull(interfaceMethodName),
-                                              Objects.requireNonNull(interfaceMethodType),
-                                              Objects.requireNonNull(implementation),
-                                              Objects.requireNonNull(dynamicMethodType),
-                                              false,
-                                              EMPTY_CLASS_ARRAY,
-                                              EMPTY_MT_ARRAY);
+         return metafactoryInternal(caller, interfaceMethodName, factoryType, interfaceMethodType,
+                 implementation, dynamicMethodType, null);
+     }
+ 
+     static CallSite metafactoryInternal(MethodHandles.Lookup caller,
+                                                String interfaceMethodName,
+                                                MethodType factoryType,
+                                                MethodType interfaceMethodType,
+                                                MethodHandle implementation,
+                                                MethodType dynamicMethodType,
+                                                ReflectableLambdaInfo reflectableLambdaInfo)
+             throws LambdaConversionException {
+         AbstractValidatingLambdaMetafactory mf = new InnerClassLambdaMetafactory(Objects.requireNonNull(caller),
+                 Objects.requireNonNull(factoryType),
+                 Objects.requireNonNull(interfaceMethodName),
+                 Objects.requireNonNull(interfaceMethodType),
+                 Objects.requireNonNull(implementation),
+                 Objects.requireNonNull(dynamicMethodType),
+                 false,
+                 EMPTY_CLASS_ARRAY,
+                 EMPTY_MT_ARRAY,
+                 reflectableLambdaInfo);
          mf.validateMetafactoryArgs();
          return mf.buildCallSite();
      }
  
      /**

@@ -487,10 +500,19 @@
      public static CallSite altMetafactory(MethodHandles.Lookup caller,
                                            String interfaceMethodName,
                                            MethodType factoryType,
                                            Object... args)
              throws LambdaConversionException {
+         return altMetafactoryInternal(caller, interfaceMethodName, factoryType, null, args);
+     }
+ 
+     static CallSite altMetafactoryInternal(MethodHandles.Lookup caller,
+                                           String interfaceMethodName,
+                                           MethodType factoryType,
+                                           ReflectableLambdaInfo reflectableLambdaInfo,
+                                           Object... args)
+             throws LambdaConversionException {
          Objects.requireNonNull(caller);
          Objects.requireNonNull(interfaceMethodName);
          Objects.requireNonNull(factoryType);
          Objects.requireNonNull(args);
          int argIndex = 0;

@@ -508,10 +530,11 @@
              if (altInterfaceCount > 0) {
                  altInterfaces = extractArgs(args, argIndex, Class.class, altInterfaceCount);
                  argIndex += altInterfaceCount;
              }
          }
+ 
          if ((flags & FLAG_BRIDGES) != 0) {
              int altMethodCount = extractArg(args, argIndex++, Integer.class);
              if (altMethodCount < 0) {
                  throw new IllegalArgumentException("negative argument count");
              }

@@ -535,18 +558,19 @@
              }
          }
  
          AbstractValidatingLambdaMetafactory mf
                  = new InnerClassLambdaMetafactory(caller,
-                                                   factoryType,
-                                                   interfaceMethodName,
-                                                   interfaceMethodType,
-                                                   implementation,
-                                                   dynamicMethodType,
-                                                   isSerializable,
-                                                   altInterfaces,
-                                                   altMethods);
+                 factoryType,
+                 interfaceMethodName,
+                 interfaceMethodType,
+                 implementation,
+                 dynamicMethodType,
+                 isSerializable,
+                 altInterfaces,
+                 altMethods,
+                 reflectableLambdaInfo);
          mf.validateMetafactoryArgs();
          return mf.buildCallSite();
      }
  
      private static <T> T extractArg(Object[] args, int index, Class<T> type) {