jdk-sandbox: comparison jdk/src/share/classes/java/lang/invoke/LambdaMetafactory.java

equal deleted inserted replaced

-:4f0a36582461
+:a86f1b828425
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */
 package java.lang.invoke;
+import java.io.Serializable;
+import java.util.Arrays;
 /**
 * <p>Bootstrap methods for converting lambda expressions and method references to functional interface objects.</p>
 *
 * <p>For every lambda expressions or method reference in the source code, there is a target type which is a
 * method, and the static types of the captured lambda arguments, and link a call site which, when invoked,
 * produces the lambda object.
 *
 * <p>When parameterized types are used, the instantiated type of the functional interface method may be different
 * from that in the functional interface. For example, consider
-* <code>interface I&lt;T&gt; { int m(T x); }</code> if this functional interface type is used in a lambda
+* {@code interface I<T> { int m(T x); }} if this functional interface type is used in a lambda
-* <code>I&lt;Byte&gt; v = ...</code>, we need both the actual functional interface method which has the signature
+* {@code I<Byte>; v = ...}, we need both the actual functional interface method which has the signature
-* <code>(Object)int</code> and the erased instantiated type of the functional interface method (or simply
+* {@code (Object)int} and the erased instantiated type of the functional interface method (or simply
 * <I>instantiated method type</I>), which has signature
-* <code>(Byte)int</code>.
+* {@code (Byte)int}.
-*
-* <p>While functional interfaces only have a single abstract method from the language perspective (concrete
-* methods in Object are and default methods may be present), at the bytecode level they may actually have multiple
-* methods because of the need for bridge methods. Invoking any of these methods on the lambda object will result
-* in invoking the implementation method.
 *
 * <p>The argument list of the implementation method and the argument list of the functional interface method(s)
 * may differ in several ways.  The implementation methods may have additional arguments to accommodate arguments
 * captured by the lambda expression; there may also be differences resulting from permitted adaptations of
 * arguments, such as casting, boxing, unboxing, and primitive widening. They may also differ because of var-args,
 * or additional marker superinterfaces.
 *
 */
 public class LambdaMetafactory {
-/** Flag for alternate metafactories indicating the lambda object is must to be serializable */
+/** Flag for alternate metafactories indicating the lambda object is
+* must to be serializable */
 public static final int FLAG_SERIALIZABLE = 1 << 0;
 /**
-* Flag for alternate metafactories indicating the lambda object implements other marker interfaces
+* Flag for alternate metafactories indicating the lambda object implements
+* other marker interfaces
 * besides Serializable
 */
 public static final int FLAG_MARKERS = 1 << 1;
+/**
+* Flag for alternate metafactories indicating the lambda object requires
+* additional bridge methods
+*/
+public static final int FLAG_BRIDGES = 1 << 2;
 private static final Class<?>[] EMPTY_CLASS_ARRAY = new Class<?>[0];
+private static final MethodType[] EMPTY_MT_ARRAY = new MethodType[0];
-/**
-* Standard meta-factory for conversion of lambda expressions or method references to functional interfaces.
+/**
-*
+* Standard meta-factory for conversion of lambda expressions or method
-* @param caller Stacked automatically by VM; represents a lookup context with the accessibility privileges
+* references to functional interfaces.
-*               of the caller.
+*
-* @param invokedName Stacked automatically by VM; the name of the invoked method as it appears at the call site.
+* @param caller Stacked automatically by VM; represents a lookup context
+*                   with the accessibility privileges of the caller.
+* @param invokedName Stacked automatically by VM; the name of the invoked
+*                    method as it appears at the call site.
 *                    Currently unused.
-* @param invokedType Stacked automatically by VM; the signature of the invoked method, which includes the
+* @param invokedType Stacked automatically by VM; the signature of the
-*                    expected static type of the returned lambda object, and the static types of the captured
+*                    invoked method, which includes the expected static
-*                    arguments for the lambda.  In the event that the implementation method is an instance method,
+*                    type of the returned lambda object, and the static
-*                    the first argument in the invocation signature will correspond to the receiver.
+*                    types of the captured arguments for the lambda.
-* @param samMethod The primary method in the functional interface to which the lambda or method reference is
+*                    In the event that the implementation method is an
-*                  being converted, represented as a method handle.
+*                    instance method, the first argument in the invocation
-* @param implMethod The implementation method which should be called (with suitable adaptation of argument
+*                    signature will correspond to the receiver.
-*                   types, return types, and adjustment for captured arguments) when methods of the resulting
+* @param samMethod The primary method in the functional interface to which
-*                   functional interface instance are invoked.
+*                  the lambda or method reference is being converted,
-* @param instantiatedMethodType The signature of the primary functional interface method after type variables
+*                  represented as a method handle.
-*                               are substituted with their instantiation from the capture site
+* @param implMethod The implementation method which should be called
-* @return a CallSite, which, when invoked, will return an instance of the functional interface
+*                   (with suitable adaptation of argument types, return
+*                   types, and adjustment for captured arguments) when
+*                   methods of the resulting functional interface instance
+*                   are invoked.
+* @param instantiatedMethodType The signature of the primary functional
+*                               interface method after type variables
+*                               are substituted with their instantiation
+*                               from the capture site
+* @return a CallSite, which, when invoked, will return an instance of the
+* functional interface
 * @throws ReflectiveOperationException
-* @throws LambdaConversionException If any of the meta-factory protocol invariants are violated
+* @throws LambdaConversionException If any of the meta-factory protocol
+* invariants are violated
 */
 public static CallSite metaFactory(MethodHandles.Lookup caller,
 String invokedName,
 MethodType invokedType,
 MethodHandle samMethod,
 MethodHandle implMethod,
 MethodType instantiatedMethodType)
 throws ReflectiveOperationException, LambdaConversionException {
 AbstractValidatingLambdaMetafactory mf;
-mf = new InnerClassLambdaMetafactory(caller, invokedType, samMethod, implMethod, instantiatedMethodType,
+mf = new InnerClassLambdaMetafactory(caller, invokedType, samMethod,
-0, EMPTY_CLASS_ARRAY);
+implMethod, instantiatedMethodType,
+false, EMPTY_CLASS_ARRAY, EMPTY_MT_ARRAY);
 mf.validateMetafactoryArgs();
 return mf.buildCallSite();
 }
 /**
-* Alternate meta-factory for conversion of lambda expressions or method references to functional interfaces,
+* Alternate meta-factory for conversion of lambda expressions or method
-* which supports serialization and other uncommon options.
+* references to functional interfaces, which supports serialization and
+* other uncommon options.
 *
 * The declared argument list for this method is:
 *
 *  CallSite altMetaFactory(MethodHandles.Lookup caller,
 *                          String invokedName,
 *                          MethodHandle implMethod,
 *                          MethodType instantiatedMethodType,
 *                          int flags,
 *                          int markerInterfaceCount, // IF flags has MARKERS set
 *                          Class... markerInterfaces // IF flags has MARKERS set
+*                          int bridgeCount,          // IF flags has BRIDGES set
+*                          MethodType... bridges     // IF flags has BRIDGES set
 *                          )
 *
 *
-* @param caller Stacked automatically by VM; represents a lookup context with the accessibility privileges
+* @param caller Stacked automatically by VM; represents a lookup context
-*               of the caller.
+*               with the accessibility privileges of the caller.
-* @param invokedName Stacked automatically by VM; the name of the invoked method as it appears at the call site.
+* @param invokedName Stacked automatically by VM; the name of the invoked
-*                    Currently unused.
+*                    method as it appears at the call site. Currently unused.
-* @param invokedType Stacked automatically by VM; the signature of the invoked method, which includes thefu
+* @param invokedType Stacked automatically by VM; the signature of the
-*                    expected static type of the returned lambda object, and the static types of the captured
+*                    invoked method, which includes the expected static
-*                    arguments for the lambda.  In the event that the implementation method is an instance method,
+*                    type of the returned lambda object, and the static
-*                    the first argument in the invocation signature will correspond to the receiver.
+*                    types of the captured arguments for the lambda.
-* @param  args       argument to pass, flags, marker interface count, and marker interfaces as described above
+*                    In the event that the implementation method is an
-* @return a CallSite, which, when invoked, will return an instance of the functional interface
+*                    instance method, the first argument in the invocation
+*                    signature will correspond to the receiver.
+* @param  args       flags and optional arguments, as described above
+* @return a CallSite, which, when invoked, will return an instance of the
+* functional interface
 * @throws ReflectiveOperationException
-* @throws LambdaConversionException If any of the meta-factory protocol invariants are violated
+* @throws LambdaConversionException If any of the meta-factory protocol
+* invariants are violated
 */
 public static CallSite altMetaFactory(MethodHandles.Lookup caller,
 String invokedName,
 MethodType invokedType,
 Object... args)
 MethodHandle samMethod = (MethodHandle)args[0];
 MethodHandle implMethod = (MethodHandle)args[1];
 MethodType instantiatedMethodType = (MethodType)args[2];
 int flags = (Integer) args[3];
 Class<?>[] markerInterfaces;
+MethodType[] bridges;
 int argIndex = 4;
 if ((flags & FLAG_MARKERS) != 0) {
 int markerCount = (Integer) args[argIndex++];
 markerInterfaces = new Class<?>[markerCount];
 System.arraycopy(args, argIndex, markerInterfaces, 0, markerCount);
 argIndex += markerCount;
 }
 else
 markerInterfaces = EMPTY_CLASS_ARRAY;
-AbstractValidatingLambdaMetafactory mf;
+if ((flags & FLAG_BRIDGES) != 0) {
-mf = new InnerClassLambdaMetafactory(caller, invokedType, samMethod, implMethod, instantiatedMethodType,
+int bridgeCount = (Integer) args[argIndex++];
-flags, markerInterfaces);
+bridges = new MethodType[bridgeCount];
+System.arraycopy(args, argIndex, bridges, 0, bridgeCount);
+argIndex += bridgeCount;
+}
+else
+bridges = EMPTY_MT_ARRAY;
+boolean foundSerializableSupertype = Serializable.class.isAssignableFrom(invokedType.returnType());
+for (Class<?> c : markerInterfaces)
+foundSerializableSupertype |= Serializable.class.isAssignableFrom(c);
+boolean isSerializable = ((flags & LambdaMetafactory.FLAG_SERIALIZABLE) != 0)
+|| foundSerializableSupertype;
+if (isSerializable && !foundSerializableSupertype) {
+markerInterfaces = Arrays.copyOf(markerInterfaces, markerInterfaces.length + 1);
+markerInterfaces[markerInterfaces.length-1] = Serializable.class;
+}
+AbstractValidatingLambdaMetafactory mf
+= new InnerClassLambdaMetafactory(caller, invokedType, samMethod,
+implMethod, instantiatedMethodType,
+isSerializable, markerInterfaces, bridges);
 mf.validateMetafactoryArgs();
 return mf.buildCallSite();
 }
 }

changeset 18182	a86f1b828425
parent 16036	a30224365db2
child 18284	e281a0a2583e