mirror of
https://github.com/openjdk/jdk.git
synced 2025-08-27 14:54:52 +02:00
569 lines
31 KiB
Java
569 lines
31 KiB
Java
/*
|
|
* Copyright (c) 2012, 2024, Oracle and/or its affiliates. All rights reserved.
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* This code is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License version 2 only, as
|
|
* published by the Free Software Foundation. Oracle designates this
|
|
* particular file as subject to the "Classpath" exception as provided
|
|
* by Oracle in the LICENSE file that accompanied this code.
|
|
*
|
|
* This code is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
* version 2 for more details (a copy is included in the LICENSE file that
|
|
* accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU General Public License version
|
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
* 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;
|
|
import java.lang.reflect.Array;
|
|
import java.util.Objects;
|
|
|
|
/**
|
|
* <p>Methods to facilitate the creation of simple "function objects" that
|
|
* implement one or more interfaces by delegation to a provided {@link MethodHandle},
|
|
* possibly after type adaptation and partial evaluation of arguments. These
|
|
* methods are typically used as <em>bootstrap methods</em> for {@code invokedynamic}
|
|
* call sites, to support the <em>lambda expression</em> and <em>method
|
|
* reference expression</em> features of the Java Programming Language.
|
|
*
|
|
* <p>Indirect access to the behavior specified by the provided {@code MethodHandle}
|
|
* proceeds in order through three phases:
|
|
* <ul>
|
|
* <li><p><em>Linkage</em> occurs when the methods in this class are invoked.
|
|
* They take as arguments an interface to be implemented (typically a
|
|
* <em>functional interface</em>, one with a single abstract method), a
|
|
* name and signature of a method from that interface to be implemented, a
|
|
* {@linkplain MethodHandleInfo direct method handle} describing the desired
|
|
* implementation behavior for that method, and possibly other additional
|
|
* metadata, and produce a {@link CallSite} whose target can be used to
|
|
* create suitable function objects.
|
|
*
|
|
* <p>Linkage may involve dynamically loading a new class that implements
|
|
* the target interface, or re-using a suitable existing class.
|
|
*
|
|
* <p>The {@code CallSite} can be considered a "factory" for function
|
|
* objects and so these linkage methods are referred to as
|
|
* "metafactories".</li>
|
|
*
|
|
* <li><p><em>Capture</em> occurs when the {@code CallSite}'s target is
|
|
* invoked, typically through an {@code invokedynamic} call site,
|
|
* producing a function object. This may occur many times for
|
|
* a single factory {@code CallSite}.
|
|
*
|
|
* <p>If the behavior {@code MethodHandle} has additional parameters beyond
|
|
* those of the specified interface method, these are referred to as
|
|
* <em>captured parameters</em>, which must be provided as arguments to the
|
|
* {@code CallSite} target. The expected number and types of captured
|
|
* parameters are determined during linkage.
|
|
*
|
|
* <p>Capture may involve allocation of a new function object, or may return
|
|
* a suitable existing function object. The identity of a function object
|
|
* produced by capture is unpredictable, and therefore identity-sensitive
|
|
* operations (such as reference equality, object locking, and {@code
|
|
* System.identityHashCode()}) may produce different results in different
|
|
* implementations, or even upon different invocations in the same
|
|
* implementation.</li>
|
|
*
|
|
* <li><p><em>Invocation</em> occurs when an implemented interface method is
|
|
* invoked on a function object. This may occur many times for a single
|
|
* function object. The method referenced by the implementation
|
|
* {@code MethodHandle} is invoked, passing to it the captured arguments and
|
|
* the invocation arguments. The result of the method is returned.
|
|
* </li>
|
|
* </ul>
|
|
*
|
|
* <p>It is sometimes useful to restrict the set of inputs or results permitted
|
|
* at invocation. For example, when the generic interface {@code Predicate<T>}
|
|
* is parameterized as {@code Predicate<String>}, the input must be a
|
|
* {@code String}, even though the method to implement allows any {@code Object}.
|
|
* At linkage time, an additional {@link MethodType} parameter describes the
|
|
* "dynamic" method type; on invocation, the arguments and eventual result
|
|
* are checked against this {@code MethodType}.
|
|
*
|
|
* <p>This class provides two forms of linkage methods: a standard version
|
|
* ({@link #metafactory(MethodHandles.Lookup, String, MethodType, MethodType, MethodHandle, MethodType)})
|
|
* using an optimized protocol, and an alternate version
|
|
* {@link #altMetafactory(MethodHandles.Lookup, String, MethodType, Object...)}).
|
|
* The alternate version is a generalization of the standard version, providing
|
|
* additional control over the behavior of the generated function objects via
|
|
* flags and additional arguments. The alternate version adds the ability to
|
|
* manage the following attributes of function objects:
|
|
*
|
|
* <ul>
|
|
* <li><em>Multiple methods.</em> It is sometimes useful to implement multiple
|
|
* variations of the method signature, involving argument or return type
|
|
* adaptation. This occurs when multiple distinct VM signatures for a method
|
|
* are logically considered to be the same method by the language. The
|
|
* flag {@code FLAG_BRIDGES} indicates that a list of additional
|
|
* {@code MethodType}s will be provided, each of which will be implemented
|
|
* by the resulting function object. These methods will share the same
|
|
* name and instantiated type.</li>
|
|
*
|
|
* <li><em>Multiple interfaces.</em> If needed, more than one interface
|
|
* can be implemented by the function object. (These additional interfaces
|
|
* are typically marker interfaces with no methods.) The flag {@code FLAG_MARKERS}
|
|
* indicates that a list of additional interfaces will be provided, each of
|
|
* which should be implemented by the resulting function object.</li>
|
|
*
|
|
* <li><em>Serializability.</em> The generated function objects do not
|
|
* generally support serialization. If desired, {@code FLAG_SERIALIZABLE}
|
|
* can be used to indicate that the function objects should be serializable.
|
|
* Serializable function objects will use, as their serialized form,
|
|
* instances of the class {@code SerializedLambda}, which requires additional
|
|
* assistance from the capturing class (the class described by the
|
|
* {@link MethodHandles.Lookup} parameter {@code caller}); see
|
|
* {@link SerializedLambda} for details.</li>
|
|
* </ul>
|
|
*
|
|
* <p>Assume the linkage arguments are as follows:
|
|
* <ul>
|
|
* <li>{@code factoryType} (describing the {@code CallSite} signature) has
|
|
* K parameters of types (D1..Dk) and return type Rd;</li>
|
|
* <li>{@code interfaceMethodType} (describing the implemented method type) has N
|
|
* parameters, of types (U1..Un) and return type Ru;</li>
|
|
* <li>{@code implementation} (the {@code MethodHandle} providing the
|
|
* implementation) has M parameters, of types (A1..Am) and return type Ra
|
|
* (if the method describes an instance method, the method type of this
|
|
* method handle already includes an extra first argument corresponding to
|
|
* the receiver);</li>
|
|
* <li>{@code dynamicMethodType} (allowing restrictions on invocation)
|
|
* has N parameters, of types (T1..Tn) and return type Rt.</li>
|
|
* </ul>
|
|
*
|
|
* <p>Then the following linkage invariants must hold:
|
|
* <ul>
|
|
* <li>{@code interfaceMethodType} and {@code dynamicMethodType} have the same
|
|
* arity N, and for i=1..N, Ti and Ui are the same type, or Ti and Ui are
|
|
* both reference types and Ti is a subtype of Ui</li>
|
|
* <li>Either Rt and Ru are the same type, or both are reference types and
|
|
* Rt is a subtype of Ru</li>
|
|
* <li>K + N = M</li>
|
|
* <li>For i=1..K, Di = Ai</li>
|
|
* <li>For i=1..N, Ti is adaptable to Aj, where j=i+k</li>
|
|
* <li>The return type Rt is void, or the return type Ra is not void and is
|
|
* adaptable to Rt</li>
|
|
* </ul>
|
|
*
|
|
* <p>Further, at capture time, if {@code implementation} corresponds to an instance
|
|
* method, and there are any capture arguments ({@code K > 0}), then the first
|
|
* capture argument (corresponding to the receiver) must be non-null.
|
|
*
|
|
* <p>A type Q is considered adaptable to S as follows:
|
|
* <table class="striped">
|
|
* <caption style="display:none">adaptable types</caption>
|
|
* <thead>
|
|
* <tr><th scope="col">Q</th><th scope="col">S</th><th scope="col">Link-time checks</th><th scope="col">Invocation-time checks</th></tr>
|
|
* </thead>
|
|
* <tbody>
|
|
* <tr>
|
|
* <th scope="row">Primitive</th><th scope="row">Primitive</th>
|
|
* <td>Q can be converted to S via a primitive widening conversion</td>
|
|
* <td>None</td>
|
|
* </tr>
|
|
* <tr>
|
|
* <th scope="row">Primitive</th><th scope="row">Reference</th>
|
|
* <td>S is a supertype of the Wrapper(Q)</td>
|
|
* <td>Cast from Wrapper(Q) to S</td>
|
|
* </tr>
|
|
* <tr>
|
|
* <th scope="row">Reference</th><th scope="row">Primitive</th>
|
|
* <td>for parameter types: Q is a primitive wrapper and Primitive(Q)
|
|
* can be widened to S
|
|
* <br>for return types: If Q is a primitive wrapper, check that
|
|
* Primitive(Q) can be widened to S</td>
|
|
* <td>If Q is not a primitive wrapper, cast Q to the base Wrapper(S);
|
|
* for example Number for numeric types</td>
|
|
* </tr>
|
|
* <tr>
|
|
* <th scope="row">Reference</th><th scope="row">Reference</th>
|
|
* <td>for parameter types: S is a supertype of Q
|
|
* <br>for return types: none</td>
|
|
* <td>Cast from Q to S</td>
|
|
* </tr>
|
|
* </tbody>
|
|
* </table>
|
|
*
|
|
* @apiNote These linkage methods are designed to support the evaluation
|
|
* of <em>lambda expressions</em> and <em>method references</em> in the Java
|
|
* Language. For every lambda expressions or method reference in the source code,
|
|
* there is a target type which is a functional interface. Evaluating a lambda
|
|
* expression produces an object of its target type. The recommended mechanism
|
|
* for evaluating lambda expressions is to desugar the lambda body to a method,
|
|
* invoke an invokedynamic call site whose static argument list describes the
|
|
* sole method of the functional interface and the desugared implementation
|
|
* method, and returns an object (the lambda object) that implements the target
|
|
* type. (For method references, the implementation method is simply the
|
|
* referenced method; no desugaring is needed.)
|
|
*
|
|
* <p>The argument list of the implementation method and the argument list of
|
|
* the 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. (Varargs adaptations are not handled by the metafactories; these are
|
|
* expected to be handled by the caller.)
|
|
*
|
|
* <p>Invokedynamic call sites have two argument lists: a static argument list
|
|
* and a dynamic argument list. The static argument list is stored in the
|
|
* constant pool; the dynamic argument is pushed on the operand stack at capture
|
|
* time. The bootstrap method has access to the entire static argument list
|
|
* (which in this case, includes information describing the implementation method,
|
|
* the target interface, and the target interface method(s)), as well as a
|
|
* method signature describing the number and static types (but not the values)
|
|
* of the dynamic arguments and the static return type of the invokedynamic site.
|
|
*
|
|
* <p>The implementation method is described with a direct method handle
|
|
* referencing a method or constructor. In theory, any method handle could be
|
|
* used, but this is not compatible with some implementation techniques and
|
|
* would complicate the work implementations must do.
|
|
*
|
|
* <p>Uses besides evaluation of lambda expressions and method references are
|
|
* unintended. These linkage methods may change their unspecified behaviors at
|
|
* any time to better suit the Java language features they were designed to
|
|
* support, and such changes may impact unintended uses. Unintended uses of
|
|
* these linkage methods may lead to resource leaks, or other unspecified
|
|
* negative effects.
|
|
*
|
|
* @implNote In the reference implementation, the classes implementing the created
|
|
* function objects are strongly reachable from the defining class loader of the
|
|
* caller, like classes and interfaces in Java source code. This technique
|
|
* reduces heap memory use, but as a consequence, the implementation classes can
|
|
* be unloaded only if the caller class can be unloaded. In particular, if the
|
|
* caller is a {@linkplain MethodHandles.Lookup.ClassOption#STRONG weak hidden
|
|
* class}, the implementation class, a strong hidden class, may not be unloaded
|
|
* even if the caller may be unloaded.
|
|
*
|
|
* @since 1.8
|
|
*/
|
|
public final class LambdaMetafactory {
|
|
|
|
private LambdaMetafactory() {}
|
|
|
|
/** Flag for {@link #altMetafactory} indicating the lambda object
|
|
* must be serializable */
|
|
public static final int FLAG_SERIALIZABLE = 1 << 0;
|
|
|
|
/**
|
|
* Flag for {@link #altMetafactory} indicating the lambda object implements
|
|
* other interfaces besides {@code Serializable}
|
|
*/
|
|
public static final int FLAG_MARKERS = 1 << 1;
|
|
|
|
/**
|
|
* Flag for alternate metafactories indicating the lambda object requires
|
|
* additional methods that invoke the {@code implementation}
|
|
*/
|
|
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];
|
|
|
|
// LambdaMetafactory bootstrap methods are startup sensitive, and may be
|
|
// special cased in java.lang.invoke.BootstrapMethodInvoker to ensure
|
|
// methods are invoked with exact type information to avoid generating
|
|
// code for runtime checks. Take care any changes or additions here are
|
|
// reflected there as appropriate.
|
|
|
|
/**
|
|
* Facilitates the creation of simple "function objects" that implement one
|
|
* or more interfaces by delegation to a provided {@link MethodHandle},
|
|
* after appropriate type adaptation and partial evaluation of arguments.
|
|
* Typically used as a <em>bootstrap method</em> for {@code invokedynamic}
|
|
* call sites, to support the <em>lambda expression</em> and <em>method
|
|
* reference expression</em> features of the Java Programming Language.
|
|
*
|
|
* <p>This is the standard, streamlined metafactory; additional flexibility
|
|
* is provided by {@link #altMetafactory(MethodHandles.Lookup, String, MethodType, Object...)}.
|
|
* A general description of the behavior of this method is provided
|
|
* {@link LambdaMetafactory above}.
|
|
*
|
|
* <p>When the target of the {@code CallSite} returned from this method is
|
|
* invoked, the resulting function objects are instances of a class which
|
|
* implements the interface named by the return type of {@code factoryType},
|
|
* declares a method with the name given by {@code interfaceMethodName} and the
|
|
* signature given by {@code interfaceMethodType}. It may also override additional
|
|
* methods from {@code Object}.
|
|
*
|
|
* @param caller Represents a lookup context with the accessibility
|
|
* privileges of the caller. Specifically, the lookup context
|
|
* must have {@linkplain MethodHandles.Lookup#hasFullPrivilegeAccess()
|
|
* full privilege access}.
|
|
* When used with {@code invokedynamic}, this is stacked
|
|
* automatically by the VM.
|
|
* @param interfaceMethodName The name of the method to implement. When used with
|
|
* {@code invokedynamic}, this is provided by the
|
|
* {@code NameAndType} of the {@code InvokeDynamic}
|
|
* structure and is stacked automatically by the VM.
|
|
* @param factoryType The expected signature of the {@code CallSite}. The
|
|
* parameter types represent the types of capture variables;
|
|
* the return type is the interface to implement. When
|
|
* used with {@code invokedynamic}, this is provided by
|
|
* the {@code NameAndType} of the {@code InvokeDynamic}
|
|
* structure and is stacked automatically by the VM.
|
|
* @param interfaceMethodType Signature and return type of method to be
|
|
* implemented by the function object.
|
|
* @param implementation A direct method handle describing the implementation
|
|
* method which should be called (with suitable adaptation
|
|
* of argument types and return types, and with captured
|
|
* arguments prepended to the invocation arguments) at
|
|
* invocation time.
|
|
* @param dynamicMethodType The signature and return type that should
|
|
* be enforced dynamically at invocation time.
|
|
* In simple use cases this is the same as
|
|
* {@code interfaceMethodType}.
|
|
* @return a CallSite whose target can be used to perform capture, generating
|
|
* instances of the interface named by {@code factoryType}
|
|
* @throws LambdaConversionException If {@code caller} does not have full privilege
|
|
* access, or if {@code interfaceMethodName} is not a valid JVM
|
|
* method name, or if the return type of {@code factoryType} is not
|
|
* an interface, or if {@code implementation} is not a direct method
|
|
* handle referencing a method or constructor, or if the linkage
|
|
* invariants are violated, as defined {@link LambdaMetafactory above}.
|
|
* @throws NullPointerException If any argument is {@code null}.
|
|
*/
|
|
public static CallSite metafactory(MethodHandles.Lookup caller,
|
|
String interfaceMethodName,
|
|
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);
|
|
mf.validateMetafactoryArgs();
|
|
return mf.buildCallSite();
|
|
}
|
|
|
|
/**
|
|
* Facilitates the creation of simple "function objects" that implement one
|
|
* or more interfaces by delegation to a provided {@link MethodHandle},
|
|
* after appropriate type adaptation and partial evaluation of arguments.
|
|
* Typically used as a <em>bootstrap method</em> for {@code invokedynamic}
|
|
* call sites, to support the <em>lambda expression</em> and <em>method
|
|
* reference expression</em> features of the Java Programming Language.
|
|
*
|
|
* <p>This is the general, more flexible metafactory; a streamlined version
|
|
* is provided by {@link #metafactory(java.lang.invoke.MethodHandles.Lookup,
|
|
* String, MethodType, MethodType, MethodHandle, MethodType)}.
|
|
* A general description of the behavior of this method is provided
|
|
* {@link LambdaMetafactory above}.
|
|
*
|
|
* <p>The argument list for this method includes three fixed parameters,
|
|
* corresponding to the parameters automatically stacked by the VM for the
|
|
* bootstrap method in an {@code invokedynamic} invocation, and an {@code Object[]}
|
|
* parameter that contains additional parameters. The declared argument
|
|
* list for this method is:
|
|
*
|
|
* <pre>{@code
|
|
* CallSite altMetafactory(MethodHandles.Lookup caller,
|
|
* String interfaceMethodName,
|
|
* MethodType factoryType,
|
|
* Object... args)
|
|
* }</pre>
|
|
*
|
|
* <p>but it behaves as if the argument list is as follows:
|
|
*
|
|
* <pre>{@code
|
|
* CallSite altMetafactory(MethodHandles.Lookup caller,
|
|
* String interfaceMethodName,
|
|
* MethodType factoryType,
|
|
* MethodType interfaceMethodType,
|
|
* MethodHandle implementation,
|
|
* MethodType dynamicMethodType,
|
|
* int flags,
|
|
* int altInterfaceCount, // IF flags has MARKERS set
|
|
* Class... altInterfaces, // IF flags has MARKERS set
|
|
* int altMethodCount, // IF flags has BRIDGES set
|
|
* MethodType... altMethods // IF flags has BRIDGES set
|
|
* )
|
|
* }</pre>
|
|
*
|
|
* <p>Arguments that appear in the argument list for
|
|
* {@link #metafactory(MethodHandles.Lookup, String, MethodType, MethodType, MethodHandle, MethodType)}
|
|
* have the same specification as in that method. The additional arguments
|
|
* are interpreted as follows:
|
|
* <ul>
|
|
* <li>{@code flags} indicates additional options; this is a bitwise
|
|
* OR of desired flags. Defined flags are {@link #FLAG_BRIDGES},
|
|
* {@link #FLAG_MARKERS}, and {@link #FLAG_SERIALIZABLE}.</li>
|
|
* <li>{@code altInterfaceCount} is the number of additional interfaces
|
|
* the function object should implement, and is present if and only if the
|
|
* {@code FLAG_MARKERS} flag is set.</li>
|
|
* <li>{@code altInterfaces} is a variable-length list of additional
|
|
* interfaces to implement, whose length equals {@code altInterfaceCount},
|
|
* and is present if and only if the {@code FLAG_MARKERS} flag is set.</li>
|
|
* <li>{@code altMethodCount} is the number of additional method signatures
|
|
* the function object should implement, and is present if and only if
|
|
* the {@code FLAG_BRIDGES} flag is set.</li>
|
|
* <li>{@code altMethods} is a variable-length list of additional
|
|
* methods signatures to implement, whose length equals {@code altMethodCount},
|
|
* and is present if and only if the {@code FLAG_BRIDGES} flag is set.</li>
|
|
* </ul>
|
|
*
|
|
* <p>Each class named by {@code altInterfaces} is subject to the same
|
|
* restrictions as {@code Rd}, the return type of {@code factoryType},
|
|
* as described {@link LambdaMetafactory above}. Each {@code MethodType}
|
|
* named by {@code altMethods} is subject to the same restrictions as
|
|
* {@code interfaceMethodType}, as described {@link LambdaMetafactory above}.
|
|
*
|
|
* <p>When FLAG_SERIALIZABLE is set in {@code flags}, the function objects
|
|
* will implement {@code Serializable}, and will have a {@code writeReplace}
|
|
* method that returns an appropriate {@link SerializedLambda}. The
|
|
* {@code caller} class must have an appropriate {@code $deserializeLambda$}
|
|
* method, as described in {@link SerializedLambda}.
|
|
*
|
|
* <p>When the target of the {@code CallSite} returned from this method is
|
|
* invoked, the resulting function objects are instances of a class with
|
|
* the following properties:
|
|
* <ul>
|
|
* <li>The class implements the interface named by the return type
|
|
* of {@code factoryType} and any interfaces named by {@code altInterfaces}</li>
|
|
* <li>The class declares methods with the name given by {@code interfaceMethodName},
|
|
* and the signature given by {@code interfaceMethodType} and additional signatures
|
|
* given by {@code altMethods}</li>
|
|
* <li>The class may override methods from {@code Object}, and may
|
|
* implement methods related to serialization.</li>
|
|
* </ul>
|
|
*
|
|
* @param caller Represents a lookup context with the accessibility
|
|
* privileges of the caller. Specifically, the lookup context
|
|
* must have {@linkplain MethodHandles.Lookup#hasFullPrivilegeAccess()
|
|
* full privilege access}.
|
|
* When used with {@code invokedynamic}, this is stacked
|
|
* automatically by the VM.
|
|
* @param interfaceMethodName The name of the method to implement. When used with
|
|
* {@code invokedynamic}, this is provided by the
|
|
* {@code NameAndType} of the {@code InvokeDynamic}
|
|
* structure and is stacked automatically by the VM.
|
|
* @param factoryType The expected signature of the {@code CallSite}. The
|
|
* parameter types represent the types of capture variables;
|
|
* the return type is the interface to implement. When
|
|
* used with {@code invokedynamic}, this is provided by
|
|
* the {@code NameAndType} of the {@code InvokeDynamic}
|
|
* structure and is stacked automatically by the VM.
|
|
* @param args An array of {@code Object} containing the required
|
|
* arguments {@code interfaceMethodType}, {@code implementation},
|
|
* {@code dynamicMethodType}, {@code flags}, and any
|
|
* optional arguments, as described above
|
|
* @return a CallSite whose target can be used to perform capture, generating
|
|
* instances of the interface named by {@code factoryType}
|
|
* @throws LambdaConversionException If {@code caller} does not have full privilege
|
|
* access, or if {@code interfaceMethodName} is not a valid JVM
|
|
* method name, or if the return type of {@code factoryType} is not
|
|
* an interface, or if any of {@code altInterfaces} is not an
|
|
* interface, or if {@code implementation} is not a direct method
|
|
* handle referencing a method or constructor, or if the linkage
|
|
* invariants are violated, as defined {@link LambdaMetafactory above}.
|
|
* @throws NullPointerException If any argument, or any component of {@code args},
|
|
* is {@code null}.
|
|
* @throws IllegalArgumentException If the number or types of the components
|
|
* of {@code args} do not follow the above rules, or if
|
|
* {@code altInterfaceCount} or {@code altMethodCount} are negative
|
|
* integers.
|
|
*/
|
|
public static CallSite altMetafactory(MethodHandles.Lookup caller,
|
|
String interfaceMethodName,
|
|
MethodType factoryType,
|
|
Object... args)
|
|
throws LambdaConversionException {
|
|
Objects.requireNonNull(caller);
|
|
Objects.requireNonNull(interfaceMethodName);
|
|
Objects.requireNonNull(factoryType);
|
|
Objects.requireNonNull(args);
|
|
int argIndex = 0;
|
|
MethodType interfaceMethodType = extractArg(args, argIndex++, MethodType.class);
|
|
MethodHandle implementation = extractArg(args, argIndex++, MethodHandle.class);
|
|
MethodType dynamicMethodType = extractArg(args, argIndex++, MethodType.class);
|
|
int flags = extractArg(args, argIndex++, Integer.class);
|
|
Class<?>[] altInterfaces = EMPTY_CLASS_ARRAY;
|
|
MethodType[] altMethods = EMPTY_MT_ARRAY;
|
|
if ((flags & FLAG_MARKERS) != 0) {
|
|
int altInterfaceCount = extractArg(args, argIndex++, Integer.class);
|
|
if (altInterfaceCount < 0) {
|
|
throw new IllegalArgumentException("negative argument count");
|
|
}
|
|
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");
|
|
}
|
|
if (altMethodCount > 0) {
|
|
altMethods = extractArgs(args, argIndex, MethodType.class, altMethodCount);
|
|
argIndex += altMethodCount;
|
|
}
|
|
}
|
|
if (argIndex < args.length) {
|
|
throw new IllegalArgumentException("too many arguments");
|
|
}
|
|
|
|
boolean isSerializable = ((flags & FLAG_SERIALIZABLE) != 0);
|
|
if (isSerializable) {
|
|
boolean foundSerializableSupertype = Serializable.class.isAssignableFrom(factoryType.returnType());
|
|
for (Class<?> c : altInterfaces)
|
|
foundSerializableSupertype |= Serializable.class.isAssignableFrom(c);
|
|
if (!foundSerializableSupertype) {
|
|
altInterfaces = Arrays.copyOf(altInterfaces, altInterfaces.length + 1);
|
|
altInterfaces[altInterfaces.length-1] = Serializable.class;
|
|
}
|
|
}
|
|
|
|
AbstractValidatingLambdaMetafactory mf
|
|
= new InnerClassLambdaMetafactory(caller,
|
|
factoryType,
|
|
interfaceMethodName,
|
|
interfaceMethodType,
|
|
implementation,
|
|
dynamicMethodType,
|
|
isSerializable,
|
|
altInterfaces,
|
|
altMethods);
|
|
mf.validateMetafactoryArgs();
|
|
return mf.buildCallSite();
|
|
}
|
|
|
|
private static <T> T extractArg(Object[] args, int index, Class<T> type) {
|
|
if (index >= args.length) {
|
|
throw new IllegalArgumentException("missing argument");
|
|
}
|
|
Object result = Objects.requireNonNull(args[index]);
|
|
if (!type.isInstance(result)) {
|
|
throw new IllegalArgumentException("argument has wrong type");
|
|
}
|
|
return type.cast(result);
|
|
}
|
|
|
|
private static <T> T[] extractArgs(Object[] args, int index, Class<T> type, int count) {
|
|
@SuppressWarnings("unchecked")
|
|
T[] result = (T[]) Array.newInstance(type, count);
|
|
for (int i = 0; i < count; i++) {
|
|
result[i] = extractArg(args, index + i, type);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
}
|