- * @author John Rose, JSR 292 EG - * @since 1.7 - */ -public class MethodHandles { - - private MethodHandles() { } // do not instantiate - - private static final MemberName.Factory IMPL_NAMES = MemberName.getFactory(); - static { MethodHandleImpl.initStatics(); } - // See IMPL_LOOKUP below. - - //// Method handle creation from ordinary methods. - - /** - * Returns a {@link Lookup lookup object} with - * full capabilities to emulate all supported bytecode behaviors of the caller. - * These capabilities include private access to the caller. - * Factory methods on the lookup object can create - * direct method handles - * for any member that the caller has access to via bytecodes, - * including protected and private fields and methods. - * This lookup object is a capability which may be delegated to trusted agents. - * Do not store it in place where untrusted code can access it. - *
- * This method is caller sensitive, which means that it may return different - * values to different callers. - *
- * For any given caller class {@code C}, the lookup object returned by this call - * has equivalent capabilities to any lookup object - * supplied by the JVM to the bootstrap method of an - * invokedynamic instruction - * executing in the same caller class {@code C}. - * @return a lookup object for the caller of this method, with private access - */ -// @CallerSensitive - public static Lookup lookup() { - throw new IllegalStateException("Implement me!"); -// return new Lookup(Reflection.getCallerClass()); - } - - /** - * Returns a {@link Lookup lookup object} which is trusted minimally. - * It can only be used to create method handles to - * publicly accessible fields and methods. - *
- * As a matter of pure convention, the {@linkplain Lookup#lookupClass lookup class} - * of this lookup object will be {@link java.lang.Object}. - * - *
- * Discussion: - * The lookup class can be changed to any other class {@code C} using an expression of the form - * {@link Lookup#in publicLookup().in(C.class)}. - * Since all classes have equal access to public names, - * such a change would confer no new access rights. - * A public lookup object is always subject to - * security manager checks. - * Also, it cannot access - * caller sensitive methods. - * @return a lookup object which is trusted minimally - */ - public static Lookup publicLookup() { - return Lookup.PUBLIC_LOOKUP; - } - - /** - * Performs an unchecked "crack" of a - * direct method handle. - * The result is as if the user had obtained a lookup object capable enough - * to crack the target method handle, called - * {@link java.lang.invoke.MethodHandles.Lookup#revealDirect Lookup.revealDirect} - * on the target to obtain its symbolic reference, and then called - * {@link java.lang.invoke.MethodHandleInfo#reflectAs MethodHandleInfo.reflectAs} - * to resolve the symbolic reference to a member. - *
- * If there is a security manager, its {@code checkPermission} method
- * is called with a {@code ReflectPermission("suppressAccessChecks")} permission.
- * @param
- * A lookup class which needs to create method handles will call
- * {@link MethodHandles#lookup MethodHandles.lookup} to create a factory for itself.
- * When the {@code Lookup} factory object is created, the identity of the lookup class is
- * determined, and securely stored in the {@code Lookup} object.
- * The lookup class (or its delegates) may then use factory methods
- * on the {@code Lookup} object to create method handles for access-checked members.
- * This includes all methods, constructors, and fields which are allowed to the lookup class,
- * even private ones.
- *
- *
- * In cases where the given member is of variable arity (i.e., a method or constructor)
- * the returned method handle will also be of {@linkplain MethodHandle#asVarargsCollector variable arity}.
- * In all other cases, the returned method handle will be of fixed arity.
- *
- * Discussion:
- * The equivalence between looked-up method handles and underlying
- * class members and bytecode behaviors
- * can break down in a few ways:
- *
- * All access checks start from a {@code Lookup} object, which
- * compares its recorded lookup class against all requests to
- * create method handles.
- * A single {@code Lookup} object can be used to create any number
- * of access-checked method handles, all checked against a single
- * lookup class.
- *
- * A {@code Lookup} object can be shared with other trusted code,
- * such as a metaobject protocol.
- * A shared {@code Lookup} object delegates the capability
- * to create method handles on private members of the lookup class.
- * Even if privileged code uses the {@code Lookup} object,
- * the access checking is confined to the privileges of the
- * original lookup class.
- *
- * A lookup can fail, because
- * the containing class is not accessible to the lookup class, or
- * because the desired class member is missing, or because the
- * desired class member is not accessible to the lookup class, or
- * because the lookup object is not trusted enough to access the member.
- * In any of these cases, a {@code ReflectiveOperationException} will be
- * thrown from the attempted lookup. The exact class will be one of
- * the following:
- *
- * In general, the conditions under which a method handle may be
- * looked up for a method {@code M} are no more restrictive than the conditions
- * under which the lookup class could have compiled, verified, and resolved a call to {@code M}.
- * Where the JVM would raise exceptions like {@code NoSuchMethodError},
- * a method handle lookup will generally raise a corresponding
- * checked exception, such as {@code NoSuchMethodException}.
- * And the effect of invoking the method handle resulting from the lookup
- * is exactly equivalent
- * to executing the compiled, verified, and resolved call to {@code M}.
- * The same point is true of fields and constructors.
- *
- * Discussion:
- * Access checks only apply to named and reflected methods,
- * constructors, and fields.
- * Other method handle creation methods, such as
- * {@link MethodHandle#asType MethodHandle.asType},
- * do not require any access checks, and are used
- * independently of any {@code Lookup} object.
- *
- * If the desired member is {@code protected}, the usual JVM rules apply,
- * including the requirement that the lookup class must be either be in the
- * same package as the desired member, or must inherit that member.
- * (See the Java Virtual Machine Specification, sections 4.9.2, 5.4.3.5, and 6.4.)
- * In addition, if the desired member is a non-static field or method
- * in a different package, the resulting method handle may only be applied
- * to objects of the lookup class or one of its subclasses.
- * This requirement is enforced by narrowing the type of the leading
- * {@code this} parameter from {@code C}
- * (which will necessarily be a superclass of the lookup class)
- * to the lookup class itself.
- *
- * The JVM imposes a similar requirement on {@code invokespecial} instruction,
- * that the receiver argument must match both the resolved method and
- * the current class. Again, this requirement is enforced by narrowing the
- * type of the leading parameter to the resulting method handle.
- * (See the Java Virtual Machine Specification, section 4.10.1.9.)
- *
- * The JVM represents constructors and static initializer blocks as internal methods
- * with special names ({@code "
- * In some cases, access between nested classes is obtained by the Java compiler by creating
- * an wrapper method to access a private method of another class
- * in the same top-level declaration.
- * For example, a nested class {@code C.D}
- * can access private members within other related classes such as
- * {@code C}, {@code C.D.E}, or {@code C.B},
- * but the Java compiler may need to generate wrapper methods in
- * those related classes. In such cases, a {@code Lookup} object on
- * {@code C.E} would be unable to those private members.
- * A workaround for this limitation is the {@link Lookup#in Lookup.in} method,
- * which can transform a lookup on {@code C.E} into one on any of those other
- * classes, without special elevation of privilege.
- *
- * The accesses permitted to a given lookup object may be limited,
- * according to its set of {@link #lookupModes lookupModes},
- * to a subset of members normally accessible to the lookup class.
- * For example, the {@link MethodHandles#publicLookup publicLookup}
- * method produces a lookup object which is only allowed to access
- * public members in public classes.
- * The caller sensitive method {@link MethodHandles#lookup lookup}
- * produces a lookup object with full capabilities relative to
- * its caller class, to emulate all supported bytecode behaviors.
- * Also, the {@link Lookup#in Lookup.in} method may produce a lookup object
- * with fewer access modes than the original lookup object.
- *
- *
- *
- * Discussion of private access:
- * We say that a lookup has private access
- * if its {@linkplain #lookupModes lookup modes}
- * include the possibility of accessing {@code private} members.
- * As documented in the relevant methods elsewhere,
- * only lookups with private access possess the following capabilities:
- *
- * Each of these permissions is a consequence of the fact that a lookup object
- * with private access can be securely traced back to an originating class,
- * whose bytecode behaviors and Java language access permissions
- * can be reliably determined and emulated by method handles.
- *
- *
- * If a security manager is present, member lookups are subject to
- * additional checks.
- * From one to three calls are made to the security manager.
- * Any of these calls can refuse access by throwing a
- * {@link java.lang.SecurityException SecurityException}.
- * Define {@code smgr} as the security manager,
- * {@code lookc} as the lookup class of the current lookup object,
- * {@code refc} as the containing class in which the member
- * is being sought, and {@code defc} as the class in which the
- * member is actually defined.
- * The value {@code lookc} is defined as not present
- * if the current lookup object does not have
- * private access.
- * The calls are made according to the following rules:
- *
- * If a method handle for a caller-sensitive method is requested,
- * the general rules for bytecode behaviors apply,
- * but they take account of the lookup class in a special way.
- * The resulting method handle behaves as if it were called
- * from an instruction contained in the lookup class,
- * so that the caller-sensitive method detects the lookup class.
- * (By contrast, the invoker of the method handle is disregarded.)
- * Thus, in the case of caller-sensitive methods,
- * different lookup classes may give rise to
- * differently behaving method handles.
- *
- * In cases where the lookup object is
- * {@link MethodHandles#publicLookup() publicLookup()},
- * or some other lookup object without
- * private access,
- * the lookup class is disregarded.
- * In such cases, no caller-sensitive method handle can be created,
- * access is forbidden, and the lookup fails with an
- * {@code IllegalAccessException}.
- *
- * Discussion:
- * For example, the caller-sensitive method
- * {@link java.lang.Class#forName(String) Class.forName(x)}
- * can return varying classes or throw varying exceptions,
- * depending on the class loader of the class that calls it.
- * A public lookup of {@code Class.forName} will fail, because
- * there is no reasonable way to determine its bytecode behavior.
- *
- * If an application caches method handles for broad sharing,
- * it should use {@code publicLookup()} to create them.
- * If there is a lookup of {@code Class.forName}, it will fail,
- * and the application must take appropriate action in that case.
- * It may be that a later lookup, perhaps during the invocation of a
- * bootstrap method, can incorporate the specific identity
- * of the caller, making the method accessible.
- *
- * The function {@code MethodHandles.lookup} is caller sensitive
- * so that there can be a secure foundation for lookups.
- * Nearly all other methods in the JSR 292 API rely on lookup
- * objects to check access requests.
- */
- public static final
- class Lookup {
- /** The class on behalf of whom the lookup is being performed. */
- private final Class lookupClass;
-
- /** The allowed sorts of members which may be looked up (PUBLIC, etc.). */
- private final int allowedModes;
-
- /** A single-bit mask representing {@code public} access,
- * which may contribute to the result of {@link #lookupModes lookupModes}.
- * The value, {@code 0x01}, happens to be the same as the value of the
- * {@code public} {@linkplain java.lang.reflect.Modifier#PUBLIC modifier bit}.
- */
- public static final int PUBLIC = Modifier.PUBLIC;
-
- /** A single-bit mask representing {@code private} access,
- * which may contribute to the result of {@link #lookupModes lookupModes}.
- * The value, {@code 0x02}, happens to be the same as the value of the
- * {@code private} {@linkplain java.lang.reflect.Modifier#PRIVATE modifier bit}.
- */
- public static final int PRIVATE = Modifier.PRIVATE;
-
- /** A single-bit mask representing {@code protected} access,
- * which may contribute to the result of {@link #lookupModes lookupModes}.
- * The value, {@code 0x04}, happens to be the same as the value of the
- * {@code protected} {@linkplain java.lang.reflect.Modifier#PROTECTED modifier bit}.
- */
- public static final int PROTECTED = Modifier.PROTECTED;
-
- /** A single-bit mask representing {@code package} access (default access),
- * which may contribute to the result of {@link #lookupModes lookupModes}.
- * The value is {@code 0x08}, which does not correspond meaningfully to
- * any particular {@linkplain java.lang.reflect.Modifier modifier bit}.
- */
- public static final int PACKAGE = Modifier.STATIC;
-
- private static final int ALL_MODES = (PUBLIC | PRIVATE | PROTECTED | PACKAGE);
- private static final int TRUSTED = -1;
-
- private static int fixmods(int mods) {
- mods &= (ALL_MODES - PACKAGE);
- return (mods != 0) ? mods : PACKAGE;
- }
-
- /** Tells which class is performing the lookup. It is this class against
- * which checks are performed for visibility and access permissions.
- *
- * The class implies a maximum level of access permission,
- * but the permissions may be additionally limited by the bitmask
- * {@link #lookupModes lookupModes}, which controls whether non-public members
- * can be accessed.
- * @return the lookup class, on behalf of which this lookup object finds members
- */
- public Class lookupClass() {
- return lookupClass;
- }
-
- // This is just for calling out to MethodHandleImpl.
- private Class lookupClassOrNull() {
- return (allowedModes == TRUSTED) ? null : lookupClass;
- }
-
- /** Tells which access-protection classes of members this lookup object can produce.
- * The result is a bit-mask of the bits
- * {@linkplain #PUBLIC PUBLIC (0x01)},
- * {@linkplain #PRIVATE PRIVATE (0x02)},
- * {@linkplain #PROTECTED PROTECTED (0x04)},
- * and {@linkplain #PACKAGE PACKAGE (0x08)}.
- *
- * A freshly-created lookup object
- * on the {@linkplain java.lang.invoke.MethodHandles#lookup() caller's class}
- * has all possible bits set, since the caller class can access all its own members.
- * A lookup object on a new lookup class
- * {@linkplain java.lang.invoke.MethodHandles.Lookup#in created from a previous lookup object}
- * may have some mode bits set to zero.
- * The purpose of this is to restrict access via the new lookup object,
- * so that it can access only names which can be reached by the original
- * lookup object, and also by the new lookup class.
- * @return the lookup modes, which limit the kinds of access performed by this lookup object
- */
- public int lookupModes() {
- return allowedModes & ALL_MODES;
- }
-
- /** Embody the current class (the lookupClass) as a lookup class
- * for method handle creation.
- * Must be called by from a method in this package,
- * which in turn is called by a method not in this package.
- */
- Lookup(Class lookupClass) {
- this(lookupClass, ALL_MODES);
- // make sure we haven't accidentally picked up a privileged class:
- checkUnprivilegedlookupClass(lookupClass, ALL_MODES);
- }
-
- private Lookup(Class lookupClass, int allowedModes) {
- this.lookupClass = lookupClass;
- this.allowedModes = allowedModes;
- }
-
- /**
- * Creates a lookup on the specified new lookup class.
- * The resulting object will report the specified
- * class as its own {@link #lookupClass lookupClass}.
- *
- * However, the resulting {@code Lookup} object is guaranteed
- * to have no more access capabilities than the original.
- * In particular, access capabilities can be lost as follows:
- * (It may seem strange that protected access should be
- * stronger than private access. Viewed independently from
- * package access, protected access is the first to be lost,
- * because it requires a direct subclass relationship between
- * caller and callee.)
- * @see #in
- */
- @Override
- public String toString() {
- String cname = lookupClass.getName();
- switch (allowedModes) {
- case 0: // no privileges
- return cname + "/noaccess";
- case PUBLIC:
- return cname + "/public";
- case PUBLIC|PACKAGE:
- return cname + "/package";
- case ALL_MODES & ~PROTECTED:
- return cname + "/private";
- case ALL_MODES:
- return cname;
- case TRUSTED:
- return "/trusted"; // internal only; not exported
- default: // Should not happen, but it's a bitfield...
- cname = cname + "/" + Integer.toHexString(allowedModes);
- assert(false) : cname;
- return cname;
- }
- }
-
- /**
- * Produces a method handle for a static method.
- * The type of the method handle will be that of the method.
- * (Since static methods do not take receivers, there is no
- * additional receiver argument inserted into the method handle type,
- * as there would be with {@link #findVirtual findVirtual} or {@link #findSpecial findSpecial}.)
- * The method and all its argument types must be accessible to the lookup object.
- *
- * The returned method handle will have
- * {@linkplain MethodHandle#asVarargsCollector variable arity} if and only if
- * the method's variable arity modifier bit ({@code 0x0080}) is set.
- *
- * If the returned method handle is invoked, the method's class will
- * be initialized, if it has not already been initialized.
- * Example:
- *
- * When called, the handle will treat the first argument as a receiver
- * and dispatch on the receiver's type to determine which method
- * implementation to enter.
- * (The dispatching action is identical with that performed by an
- * {@code invokevirtual} or {@code invokeinterface} instruction.)
- *
- * The first argument will be of type {@code refc} if the lookup
- * class has full privileges to access the member. Otherwise
- * the member must be {@code protected} and the first argument
- * will be restricted in type to the lookup class.
- *
- * The returned method handle will have
- * {@linkplain MethodHandle#asVarargsCollector variable arity} if and only if
- * the method's variable arity modifier bit ({@code 0x0080}) is set.
- *
- * Because of the general equivalence between {@code invokevirtual}
- * instructions and method handles produced by {@code findVirtual},
- * if the class is {@code MethodHandle} and the name string is
- * {@code invokeExact} or {@code invoke}, the resulting
- * method handle is equivalent to one produced by
- * {@link java.lang.invoke.MethodHandles#exactInvoker MethodHandles.exactInvoker} or
- * {@link java.lang.invoke.MethodHandles#invoker MethodHandles.invoker}
- * with the same {@code type} argument.
- *
- * Example:
- *
- * The requested type must have a return type of {@code void}.
- * (This is consistent with the JVM's treatment of constructor type descriptors.)
- *
- * The returned method handle will have
- * {@linkplain MethodHandle#asVarargsCollector variable arity} if and only if
- * the constructor's variable arity modifier bit ({@code 0x0080}) is set.
- *
- * If the returned method handle is invoked, the constructor's class will
- * be initialized, if it has not already been initialized.
- * Example:
- *
- * Before method resolution,
- * if the explicitly specified caller class is not identical with the
- * lookup class, or if this lookup object does not have
- * private access
- * privileges, the access fails.
- *
- * The returned method handle will have
- * {@linkplain MethodHandle#asVarargsCollector variable arity} if and only if
- * the method's variable arity modifier bit ({@code 0x0080}) is set.
- *
- * (Note: JVM internal methods named {@code " Example:
- *
- * If the returned method handle is invoked, the field's class will
- * be initialized, if it has not already been initialized.
- * @param refc the class or interface from which the method is accessed
- * @param name the field's name
- * @param type the field's type
- * @return a method handle which can load values from the field
- * @throws NoSuchFieldException if the field does not exist
- * @throws IllegalAccessException if access checking fails, or if the field is not {@code static}
- * @exception SecurityException if a security manager is present and it
- * refuses access
- * @throws NullPointerException if any argument is null
- */
- public MethodHandle findStaticGetter(Class refc, String name, Class type) throws NoSuchFieldException, IllegalAccessException {
- MemberName field = resolveOrFail(REF_getStatic, refc, name, type);
- return getDirectField(REF_getStatic, refc, field);
- }
-
- /**
- * Produces a method handle giving write access to a static field.
- * The type of the method handle will have a void return type.
- * The method handle will take a single
- * argument, of the field's value type, the value to be stored.
- * Access checking is performed immediately on behalf of the lookup class.
- *
- * If the returned method handle is invoked, the field's class will
- * be initialized, if it has not already been initialized.
- * @param refc the class or interface from which the method is accessed
- * @param name the field's name
- * @param type the field's type
- * @return a method handle which can store values into the field
- * @throws NoSuchFieldException if the field does not exist
- * @throws IllegalAccessException if access checking fails, or if the field is not {@code static}
- * @exception SecurityException if a security manager is present and it
- * refuses access
- * @throws NullPointerException if any argument is null
- */
- public MethodHandle findStaticSetter(Class refc, String name, Class type) throws NoSuchFieldException, IllegalAccessException {
- MemberName field = resolveOrFail(REF_putStatic, refc, name, type);
- return getDirectField(REF_putStatic, refc, field);
- }
-
- /**
- * Produces an early-bound method handle for a non-static method.
- * The receiver must have a supertype {@code defc} in which a method
- * of the given name and type is accessible to the lookup class.
- * The method and all its argument types must be accessible to the lookup object.
- * The type of the method handle will be that of the method,
- * without any insertion of an additional receiver parameter.
- * The given receiver will be bound into the method handle,
- * so that every call to the method handle will invoke the
- * requested method on the given receiver.
- *
- * The returned method handle will have
- * {@linkplain MethodHandle#asVarargsCollector variable arity} if and only if
- * the method's variable arity modifier bit ({@code 0x0080}) is set
- * and the trailing array argument is not the only argument.
- * (If the trailing array argument is the only argument,
- * the given receiver value will be bound to it.)
- *
- * This is equivalent to the following code:
- *
- * The returned method handle will have
- * {@linkplain MethodHandle#asVarargsCollector variable arity} if and only if
- * the method's variable arity modifier bit ({@code 0x0080}) is set.
- *
- * If m is static, and
- * if the returned method handle is invoked, the method's class will
- * be initialized, if it has not already been initialized.
- * @param m the reflected method
- * @return a method handle which can invoke the reflected method
- * @throws IllegalAccessException if access checking fails
- * or if the method's variable arity modifier bit
- * is set and {@code asVarargsCollector} fails
- * @throws NullPointerException if the argument is null
- */
- public MethodHandle unreflect(Method m) throws IllegalAccessException {
- if (m.getDeclaringClass() == MethodHandle.class) {
- MethodHandle mh = unreflectForMH(m);
- if (mh != null) return mh;
- }
- MemberName method = new MemberName(m);
- byte refKind = method.getReferenceKind();
- if (refKind == REF_invokeSpecial)
- refKind = REF_invokeVirtual;
- assert(method.isMethod());
- Lookup lookup = m.isAccessible() ? IMPL_LOOKUP : this;
- return lookup.getDirectMethodNoSecurityManager(refKind, method.getDeclaringClass(), method, findBoundCallerClass(method));
- }
- private MethodHandle unreflectForMH(Method m) {
- // these names require special lookups because they throw UnsupportedOperationException
- if (MemberName.isMethodHandleInvokeName(m.getName()))
- return MethodHandleImpl.fakeMethodHandleInvoke(new MemberName(m));
- return null;
- }
-
- /**
- * Produces a method handle for a reflected method.
- * It will bypass checks for overriding methods on the receiver,
- * as if called from an {@code invokespecial}
- * instruction from within the explicitly specified {@code specialCaller}.
- * The type of the method handle will be that of the method,
- * with a suitably restricted receiver type prepended.
- * (The receiver type will be {@code specialCaller} or a subtype.)
- * If the method's {@code accessible} flag is not set,
- * access checking is performed immediately on behalf of the lookup class,
- * as if {@code invokespecial} instruction were being linked.
- *
- * Before method resolution,
- * if the explicitly specified caller class is not identical with the
- * lookup class, or if this lookup object does not have
- * private access
- * privileges, the access fails.
- *
- * The returned method handle will have
- * {@linkplain MethodHandle#asVarargsCollector variable arity} if and only if
- * the method's variable arity modifier bit ({@code 0x0080}) is set.
- * @param m the reflected method
- * @param specialCaller the class nominally calling the method
- * @return a method handle which can invoke the reflected method
- * @throws IllegalAccessException if access checking fails
- * or if the method's variable arity modifier bit
- * is set and {@code asVarargsCollector} fails
- * @throws NullPointerException if any argument is null
- */
- public MethodHandle unreflectSpecial(Method m, Class specialCaller) throws IllegalAccessException {
- checkSpecialCaller(specialCaller);
- Lookup specialLookup = this.in(specialCaller);
- MemberName method = new MemberName(m, true);
- assert(method.isMethod());
- // ignore m.isAccessible: this is a new kind of access
- return specialLookup.getDirectMethodNoSecurityManager(REF_invokeSpecial, method.getDeclaringClass(), method, findBoundCallerClass(method));
- }
-
- /**
- * Produces a method handle for a reflected constructor.
- * The type of the method handle will be that of the constructor,
- * with the return type changed to the declaring class.
- * The method handle will perform a {@code newInstance} operation,
- * creating a new instance of the constructor's class on the
- * arguments passed to the method handle.
- *
- * If the constructor's {@code accessible} flag is not set,
- * access checking is performed immediately on behalf of the lookup class.
- *
- * The returned method handle will have
- * {@linkplain MethodHandle#asVarargsCollector variable arity} if and only if
- * the constructor's variable arity modifier bit ({@code 0x0080}) is set.
- *
- * If the returned method handle is invoked, the constructor's class will
- * be initialized, if it has not already been initialized.
- * @param c the reflected constructor
- * @return a method handle which can invoke the reflected constructor
- * @throws IllegalAccessException if access checking fails
- * or if the method's variable arity modifier bit
- * is set and {@code asVarargsCollector} fails
- * @throws NullPointerException if the argument is null
- */
- public MethodHandle unreflectConstructor(Constructor c) throws IllegalAccessException {
- MemberName ctor = new MemberName(c);
- assert(ctor.isConstructor());
- Lookup lookup = c.isAccessible() ? IMPL_LOOKUP : this;
- return lookup.getDirectConstructorNoSecurityManager(ctor.getDeclaringClass(), ctor);
- }
-
- /**
- * Produces a method handle giving read access to a reflected field.
- * The type of the method handle will have a return type of the field's
- * value type.
- * If the field is static, the method handle will take no arguments.
- * Otherwise, its single argument will be the instance containing
- * the field.
- * If the field's {@code accessible} flag is not set,
- * access checking is performed immediately on behalf of the lookup class.
- *
- * If the field is static, and
- * if the returned method handle is invoked, the field's class will
- * be initialized, if it has not already been initialized.
- * @param f the reflected field
- * @return a method handle which can load values from the reflected field
- * @throws IllegalAccessException if access checking fails
- * @throws NullPointerException if the argument is null
- */
- public MethodHandle unreflectGetter(Field f) throws IllegalAccessException {
- return unreflectField(f, false);
- }
- private MethodHandle unreflectField(Field f, boolean isSetter) throws IllegalAccessException {
- MemberName field = new MemberName(f, isSetter);
- assert(isSetter
- ? MethodHandleNatives.refKindIsSetter(field.getReferenceKind())
- : MethodHandleNatives.refKindIsGetter(field.getReferenceKind()));
- Lookup lookup = f.isAccessible() ? IMPL_LOOKUP : this;
- return lookup.getDirectFieldNoSecurityManager(field.getReferenceKind(), f.getDeclaringClass(), field);
- }
-
- /**
- * Produces a method handle giving write access to a reflected field.
- * The type of the method handle will have a void return type.
- * If the field is static, the method handle will take a single
- * argument, of the field's value type, the value to be stored.
- * Otherwise, the two arguments will be the instance containing
- * the field, and the value to be stored.
- * If the field's {@code accessible} flag is not set,
- * access checking is performed immediately on behalf of the lookup class.
- *
- * If the field is static, and
- * if the returned method handle is invoked, the field's class will
- * be initialized, if it has not already been initialized.
- * @param f the reflected field
- * @return a method handle which can store values into the reflected field
- * @throws IllegalAccessException if access checking fails
- * @throws NullPointerException if the argument is null
- */
- public MethodHandle unreflectSetter(Field f) throws IllegalAccessException {
- return unreflectField(f, true);
- }
-
- /**
- * Cracks a direct method handle
- * created by this lookup object or a similar one.
- * Security and access checks are performed to ensure that this lookup object
- * is capable of reproducing the target method handle.
- * This means that the cracking may fail if target is a direct method handle
- * but was created by an unrelated lookup object.
- * This can happen if the method handle is caller sensitive
- * and was created by a lookup object for a different class.
- * @param target a direct method handle to crack into symbolic reference components
- * @return a symbolic reference which can be used to reconstruct this method handle from this lookup object
- * @exception SecurityException if a security manager is present and it
- * refuses access
- * @throws IllegalArgumentException if the target is not a direct method handle or if access checking fails
- * @exception NullPointerException if the target is {@code null}
- * @see MethodHandleInfo
- * @since 1.8
- */
- public MethodHandleInfo revealDirect(MethodHandle target) {
- MemberName member = target.internalMemberName();
- if (member == null || (!member.isResolved() && !member.isMethodHandleInvoke()))
- throw newIllegalArgumentException("not a direct method handle");
- Class defc = member.getDeclaringClass();
- byte refKind = member.getReferenceKind();
- assert(MethodHandleNatives.refKindIsValid(refKind));
- if (refKind == REF_invokeSpecial && !target.isInvokeSpecial())
- // Devirtualized method invocation is usually formally virtual.
- // To avoid creating extra MemberName objects for this common case,
- // we encode this extra degree of freedom using MH.isInvokeSpecial.
- refKind = REF_invokeVirtual;
- if (refKind == REF_invokeVirtual && defc.isInterface())
- // Symbolic reference is through interface but resolves to Object method (toString, etc.)
- refKind = REF_invokeInterface;
- // Check SM permissions and member access before cracking.
- try {
- checkAccess(refKind, defc, member);
- checkSecurityManager(defc, member);
- } catch (IllegalAccessException ex) {
- throw new IllegalArgumentException(ex);
- }
- if (allowedModes != TRUSTED && member.isCallerSensitive()) {
- Class callerClass = target.internalCallerClass();
- if (!hasPrivateAccess() || callerClass != lookupClass())
- throw new IllegalArgumentException("method handle is caller sensitive: "+callerClass);
- }
- // Produce the handle to the results.
- return new InfoFromMemberName(this, member, refKind);
- }
-
- /// Helper methods, all package-private.
-
- MemberName resolveOrFail(byte refKind, Class refc, String name, Class type) throws NoSuchFieldException, IllegalAccessException {
- checkSymbolicClass(refc); // do this before attempting to resolve
- name.getClass(); // NPE
- type.getClass(); // NPE
- return IMPL_NAMES.resolveOrFail(refKind, new MemberName(refc, name, type, refKind), lookupClassOrNull(),
- NoSuchFieldException.class);
- }
-
- MemberName resolveOrFail(byte refKind, Class refc, String name, MethodType type) throws NoSuchMethodException, IllegalAccessException {
- checkSymbolicClass(refc); // do this before attempting to resolve
- name.getClass(); // NPE
- type.getClass(); // NPE
- checkMethodName(refKind, name); // NPE check on name
- return IMPL_NAMES.resolveOrFail(refKind, new MemberName(refc, name, type, refKind), lookupClassOrNull(),
- NoSuchMethodException.class);
- }
-
- MemberName resolveOrFail(byte refKind, MemberName member) throws ReflectiveOperationException {
- checkSymbolicClass(member.getDeclaringClass()); // do this before attempting to resolve
- member.getName().getClass(); // NPE
- member.getType().getClass(); // NPE
- return IMPL_NAMES.resolveOrFail(refKind, member, lookupClassOrNull(),
- ReflectiveOperationException.class);
- }
-
- void checkSymbolicClass(Class refc) throws IllegalAccessException {
- refc.getClass(); // NPE
- Class caller = lookupClassOrNull();
- if (caller != null && !VerifyAccess.isClassAccessible(refc, caller, allowedModes))
- throw new MemberName(refc).makeAccessException("symbolic reference class is not public", this);
- }
-
- /** Check name for an illegal leading "<" character. */
- void checkMethodName(byte refKind, String name) throws NoSuchMethodException {
- if (name.startsWith("<") && refKind != REF_newInvokeSpecial)
- throw new NoSuchMethodException("illegal method name: "+name);
- }
-
-
- /**
- * Find my trustable caller class if m is a caller sensitive method.
- * If this lookup object has private access, then the caller class is the lookupClass.
- * Otherwise, if m is caller-sensitive, throw IllegalAccessException.
- */
- Class findBoundCallerClass(MemberName m) throws IllegalAccessException {
- Class callerClass = null;
- if (MethodHandleNatives.isCallerSensitive(m)) {
- // Only lookups with private access are allowed to resolve caller-sensitive methods
- if (hasPrivateAccess()) {
- callerClass = lookupClass;
- } else {
- throw new IllegalAccessException("Attempt to lookup caller-sensitive method using restricted lookup object");
- }
- }
- return callerClass;
- }
-
- private boolean hasPrivateAccess() {
- return (allowedModes & PRIVATE) != 0;
- }
-
- /**
- * Perform necessary access checks.
- * Determines a trustable caller class to compare with refc, the symbolic reference class.
- * If this lookup object has private access, then the caller class is the lookupClass.
- */
- void checkSecurityManager(Class refc, MemberName m) {
-// SecurityManager smgr = System.getSecurityManager();
-// if (smgr == null) return;
-// if (allowedModes == TRUSTED) return;
-//
-// // Step 1:
-// boolean fullPowerLookup = hasPrivateAccess();
-// if (!fullPowerLookup ||
-// !VerifyAccess.classLoaderIsAncestor(lookupClass, refc)) {
-// ReflectUtil.checkPackageAccess(refc);
-// }
-//
-// // Step 2:
-// if (m.isPublic()) return;
-// if (!fullPowerLookup) {
-// smgr.checkPermission(SecurityConstants.CHECK_MEMBER_ACCESS_PERMISSION);
-// }
-//
-// // Step 3:
-// Class defc = m.getDeclaringClass();
-// if (!fullPowerLookup && defc != refc) {
-// ReflectUtil.checkPackageAccess(defc);
-// }
- }
-
- void checkMethod(byte refKind, Class refc, MemberName m) throws IllegalAccessException {
- boolean wantStatic = (refKind == REF_invokeStatic);
- String message;
- if (m.isConstructor())
- message = "expected a method, not a constructor";
- else if (!m.isMethod())
- message = "expected a method";
- else if (wantStatic != m.isStatic())
- message = wantStatic ? "expected a static method" : "expected a non-static method";
- else
- { checkAccess(refKind, refc, m); return; }
- throw m.makeAccessException(message, this);
- }
-
- void checkField(byte refKind, Class refc, MemberName m) throws IllegalAccessException {
- boolean wantStatic = !MethodHandleNatives.refKindHasReceiver(refKind);
- String message;
- if (wantStatic != m.isStatic())
- message = wantStatic ? "expected a static field" : "expected a non-static field";
- else
- { checkAccess(refKind, refc, m); return; }
- throw m.makeAccessException(message, this);
- }
-
- /** Check public/protected/private bits on the symbolic reference class and its member. */
- void checkAccess(byte refKind, Class refc, MemberName m) throws IllegalAccessException {
- assert(m.referenceKindIsConsistentWith(refKind) &&
- MethodHandleNatives.refKindIsValid(refKind) &&
- (MethodHandleNatives.refKindIsField(refKind) == m.isField()));
- int allowedModes = this.allowedModes;
- if (allowedModes == TRUSTED) return;
- int mods = m.getModifiers();
- if (Modifier.isProtected(mods) &&
- refKind == REF_invokeVirtual &&
- m.getDeclaringClass() == Object.class &&
- m.getName().equals("clone") &&
- refc.isArray()) {
- // The JVM does this hack also.
- // (See ClassVerifier::verify_invoke_instructions
- // and LinkResolver::check_method_accessability.)
- // Because the JVM does not allow separate methods on array types,
- // there is no separate method for int[].clone.
- // All arrays simply inherit Object.clone.
- // But for access checking logic, we make Object.clone
- // (normally protected) appear to be public.
- // Later on, when the DirectMethodHandle is created,
- // its leading argument will be restricted to the
- // requested array type.
- // N.B. The return type is not adjusted, because
- // that is *not* the bytecode behavior.
- mods ^= Modifier.PROTECTED | Modifier.PUBLIC;
- }
- if (Modifier.isFinal(mods) &&
- MethodHandleNatives.refKindIsSetter(refKind))
- throw m.makeAccessException("unexpected set of a final field", this);
- if (Modifier.isPublic(mods) && Modifier.isPublic(refc.getModifiers()) && allowedModes != 0)
- return; // common case
- int requestedModes = fixmods(mods); // adjust 0 => PACKAGE
- if ((requestedModes & allowedModes) != 0) {
- if (VerifyAccess.isMemberAccessible(refc, m.getDeclaringClass(),
- mods, lookupClass(), allowedModes))
- return;
- } else {
- // Protected members can also be checked as if they were package-private.
- if ((requestedModes & PROTECTED) != 0 && (allowedModes & PACKAGE) != 0
- && VerifyAccess.isSamePackage(m.getDeclaringClass(), lookupClass()))
- return;
- }
- throw m.makeAccessException(accessFailedMessage(refc, m), this);
- }
-
- String accessFailedMessage(Class refc, MemberName m) {
- Class defc = m.getDeclaringClass();
- int mods = m.getModifiers();
- // check the class first:
- boolean classOK = (Modifier.isPublic(defc.getModifiers()) &&
- (defc == refc ||
- Modifier.isPublic(refc.getModifiers())));
- if (!classOK && (allowedModes & PACKAGE) != 0) {
- classOK = (VerifyAccess.isClassAccessible(defc, lookupClass(), ALL_MODES) &&
- (defc == refc ||
- VerifyAccess.isClassAccessible(refc, lookupClass(), ALL_MODES)));
- }
- if (!classOK)
- return "class is not public";
- if (Modifier.isPublic(mods))
- return "access to public member failed"; // (how?)
- if (Modifier.isPrivate(mods))
- return "member is private";
- if (Modifier.isProtected(mods))
- return "member is protected";
- return "member is private to package";
- }
-
- private static final boolean ALLOW_NESTMATE_ACCESS = false;
-
- private void checkSpecialCaller(Class specialCaller) throws IllegalAccessException {
- int allowedModes = this.allowedModes;
- if (allowedModes == TRUSTED) return;
- if (!hasPrivateAccess()
- || (specialCaller != lookupClass()
- && !(ALLOW_NESTMATE_ACCESS &&
- VerifyAccess.isSamePackageMember(specialCaller, lookupClass()))))
- throw new MemberName(specialCaller).
- makeAccessException("no private access for invokespecial", this);
- }
-
- private boolean restrictProtectedReceiver(MemberName method) {
- // The accessing class only has the right to use a protected member
- // on itself or a subclass. Enforce that restriction, from JVMS 5.4.4, etc.
- if (!method.isProtected() || method.isStatic()
- || allowedModes == TRUSTED
- || method.getDeclaringClass() == lookupClass()
- || VerifyAccess.isSamePackage(method.getDeclaringClass(), lookupClass())
- || (ALLOW_NESTMATE_ACCESS &&
- VerifyAccess.isSamePackageMember(method.getDeclaringClass(), lookupClass())))
- return false;
- return true;
- }
- private MethodHandle restrictReceiver(MemberName method, MethodHandle mh, Class caller) throws IllegalAccessException {
- assert(!method.isStatic());
- // receiver type of mh is too wide; narrow to caller
- if (!method.getDeclaringClass().isAssignableFrom(caller)) {
- throw method.makeAccessException("caller class must be a subclass below the method", caller);
- }
- MethodType rawType = mh.type();
- if (rawType.parameterType(0) == caller) return mh;
- MethodType narrowType = rawType.changeParameterType(0, caller);
- return mh.viewAsType(narrowType);
- }
-
- /** Check access and get the requested method. */
- private MethodHandle getDirectMethod(byte refKind, Class refc, MemberName method, Class callerClass) throws IllegalAccessException {
- final boolean doRestrict = true;
- final boolean checkSecurity = true;
- return getDirectMethodCommon(refKind, refc, method, checkSecurity, doRestrict, callerClass);
- }
- /** Check access and get the requested method, eliding receiver narrowing rules. */
- private MethodHandle getDirectMethodNoRestrict(byte refKind, Class refc, MemberName method, Class callerClass) throws IllegalAccessException {
- final boolean doRestrict = false;
- final boolean checkSecurity = true;
- return getDirectMethodCommon(refKind, refc, method, checkSecurity, doRestrict, callerClass);
- }
- /** Check access and get the requested method, eliding security manager checks. */
- private MethodHandle getDirectMethodNoSecurityManager(byte refKind, Class refc, MemberName method, Class callerClass) throws IllegalAccessException {
- final boolean doRestrict = true;
- final boolean checkSecurity = false; // not needed for reflection or for linking CONSTANT_MH constants
- return getDirectMethodCommon(refKind, refc, method, checkSecurity, doRestrict, callerClass);
- }
- /** Common code for all methods; do not call directly except from immediately above. */
- private MethodHandle getDirectMethodCommon(byte refKind, Class refc, MemberName method,
- boolean checkSecurity,
- boolean doRestrict, Class callerClass) throws IllegalAccessException {
- checkMethod(refKind, refc, method);
- // Optionally check with the security manager; this isn't needed for unreflect* calls.
- if (checkSecurity)
- checkSecurityManager(refc, method);
- assert(!method.isMethodHandleInvoke());
-
- Class refcAsSuper;
- if (refKind == REF_invokeSpecial &&
- refc != lookupClass() &&
- !refc.isInterface() &&
- refc != (refcAsSuper = lookupClass().getSuperclass()) &&
- refc.isAssignableFrom(lookupClass())) {
- assert(!method.getName().equals("
- * The invoker will invoke its target like a call to {@link MethodHandle#invoke invoke} with
- * the indicated {@code type}.
- * That is, if the target is exactly of the given {@code type}, it will behave
- * like {@code invokeExact}; otherwise it behave as if {@link MethodHandle#asType asType}
- * is used to convert the target to the required {@code type}.
- *
- * The type of the returned invoker will not be the given {@code type}, but rather
- * will have all parameters except the first {@code leadingArgCount}
- * replaced by a single array of type {@code Object[]}, which will be
- * the final parameter.
- *
- * Before invoking its target, the invoker will spread the final array, apply
- * reference casts as necessary, and unbox and widen primitive arguments.
- * If, when the invoker is called, the supplied array argument does
- * not have the correct number of elements, the invoker will throw
- * an {@link IllegalArgumentException} instead of invoking the target.
- *
- * This method is equivalent to the following code (though it may be more efficient):
- *
- * This method is equivalent to the following code (though it may be more efficient):
- * {@code publicLookup().findVirtual(MethodHandle.class, "invokeExact", type)}
- *
- *
- * Discussion:
- * Invoker method handles can be useful when working with variable method handles
- * of unknown types.
- * For example, to emulate an {@code invokeExact} call to a variable method
- * handle {@code M}, extract its type {@code T},
- * look up the invoker method {@code X} for {@code T},
- * and call the invoker method, as {@code X.invoke(T, A...)}.
- * (It would not work to call {@code X.invokeExact}, since the type {@code T}
- * is unknown.)
- * If spreading, collecting, or other argument transformations are required,
- * they can be applied once to the invoker {@code X} and reused on many {@code M}
- * method handle values, as long as they are compatible with the type of {@code X}.
- *
- * (Note: The invoker method is not available via the Core Reflection API.
- * An attempt to call {@linkplain java.lang.reflect.Method#invoke java.lang.reflect.Method.invoke}
- * on the declared {@code invokeExact} or {@code invoke} method will raise an
- * {@link java.lang.UnsupportedOperationException UnsupportedOperationException}.)
- *
- * This method throws no reflective or security exceptions.
- * @param type the desired target type
- * @return a method handle suitable for invoking any method handle of the given type
- * @throws IllegalArgumentException if the resulting method handle's type would have
- * too many parameters
- */
- static public
- MethodHandle exactInvoker(MethodType type) {
- return type.invokers().exactInvoker();
- }
-
- /**
- * Produces a special invoker method handle which can be used to
- * invoke any method handle compatible with the given type, as if by {@link MethodHandle#invoke invoke}.
- * The resulting invoker will have a type which is
- * exactly equal to the desired type, except that it will accept
- * an additional leading argument of type {@code MethodHandle}.
- *
- * Before invoking its target, if the target differs from the expected type,
- * the invoker will apply reference casts as
- * necessary and box, unbox, or widen primitive values, as if by {@link MethodHandle#asType asType}.
- * Similarly, the return value will be converted as necessary.
- * If the target is a {@linkplain MethodHandle#asVarargsCollector variable arity method handle},
- * the required arity conversion will be made, again as if by {@link MethodHandle#asType asType}.
- *
- * This method is equivalent to the following code (though it may be more efficient):
- * {@code publicLookup().findVirtual(MethodHandle.class, "invoke", type)}
- *
- * Discussion:
- * A {@linkplain MethodType#genericMethodType general method type} is one which
- * mentions only {@code Object} arguments and return values.
- * An invoker for such a type is capable of calling any method handle
- * of the same arity as the general type.
- *
- * (Note: The invoker method is not available via the Core Reflection API.
- * An attempt to call {@linkplain java.lang.reflect.Method#invoke java.lang.reflect.Method.invoke}
- * on the declared {@code invokeExact} or {@code invoke} method will raise an
- * {@link java.lang.UnsupportedOperationException UnsupportedOperationException}.)
- *
- * This method throws no reflective or security exceptions.
- * @param type the desired target type
- * @return a method handle suitable for invoking any method handle convertible to the given type
- * @throws IllegalArgumentException if the resulting method handle's type would have
- * too many parameters
- */
- static public
- MethodHandle invoker(MethodType type) {
- return type.invokers().generalInvoker();
- }
-
- static /*non-public*/
- MethodHandle basicInvoker(MethodType type) {
- return type.form().basicInvoker();
- }
-
- /// method handle modification (creation from other method handles)
-
- /**
- * Produces a method handle which adapts the type of the
- * given method handle to a new type by pairwise argument and return type conversion.
- * The original type and new type must have the same number of arguments.
- * The resulting method handle is guaranteed to report a type
- * which is equal to the desired new type.
- *
- * If the original type and new type are equal, returns target.
- *
- * The same conversions are allowed as for {@link MethodHandle#asType MethodHandle.asType},
- * and some additional conversions are also applied if those conversions fail.
- * Given types T0, T1, one of the following conversions is applied
- * if possible, before or instead of any conversions done by {@code asType}:
- *
- * The given array controls the reordering.
- * Call {@code #I} the number of incoming parameters (the value
- * {@code newType.parameterCount()}, and call {@code #O} the number
- * of outgoing parameters (the value {@code target.type().parameterCount()}).
- * Then the length of the reordering array must be {@code #O},
- * and each element must be a non-negative number less than {@code #I}.
- * For every {@code N} less than {@code #O}, the {@code N}-th
- * outgoing argument will be taken from the {@code I}-th incoming
- * argument, where {@code I} is {@code reorder[N]}.
- *
- * No argument or return value conversions are applied.
- * The type of each incoming argument, as determined by {@code newType},
- * must be identical to the type of the corresponding outgoing parameter
- * or parameters in the target method handle.
- * The return type of {@code newType} must be identical to the return
- * type of the original target.
- *
- * The reordering array need not specify an actual permutation.
- * An incoming argument will be duplicated if its index appears
- * more than once in the array, and an incoming argument will be dropped
- * if its index does not appear in the array.
- * As in the case of {@link #dropArguments(MethodHandle,int,List) dropArguments},
- * incoming arguments which are not mentioned in the reordering array
- * are may be any type, as determined only by {@code newType}.
- *
- * Before the method handle is returned, the passed-in value is converted to the requested type.
- * If the requested type is primitive, widening primitive conversions are attempted,
- * else reference conversions are attempted.
- * The returned method handle is equivalent to {@code identity(type).bindTo(value)}.
- * @param type the return type of the desired method handle
- * @param value the value to return
- * @return a method handle of the given return type and no arguments, which always returns the given value
- * @throws NullPointerException if the {@code type} argument is null
- * @throws ClassCastException if the value cannot be converted to the required return type
- * @throws IllegalArgumentException if the given type is {@code void.class}
- */
- public static
- MethodHandle constant(Class type, Object value) {
- if (type.isPrimitive()) {
- if (type == void.class)
- throw newIllegalArgumentException("void type");
- Wrapper w = Wrapper.forPrimitiveType(type);
- return insertArguments(identity(type), 0, w.convert(value, type));
- } else {
- return identity(type).bindTo(type.cast(value));
- }
- }
-
- /**
- * Produces a method handle which returns its sole argument when invoked.
- * @param type the type of the sole parameter and return value of the desired method handle
- * @return a unary method handle which accepts and returns the given type
- * @throws NullPointerException if the argument is null
- * @throws IllegalArgumentException if the given type is {@code void.class}
- */
- public static
- MethodHandle identity(Class type) {
- if (type == void.class)
- throw newIllegalArgumentException("void type");
- else if (type == Object.class)
- return ValueConversions.identity();
- else if (type.isPrimitive())
- return ValueConversions.identity(Wrapper.forPrimitiveType(type));
- else
- return MethodHandleImpl.makeReferenceIdentity(type);
- }
-
- /**
- * Provides a target method handle with one or more bound arguments
- * in advance of the method handle's invocation.
- * The formal parameters to the target corresponding to the bound
- * arguments are called bound parameters.
- * Returns a new method handle which saves away the bound arguments.
- * When it is invoked, it receives arguments for any non-bound parameters,
- * binds the saved arguments to their corresponding parameters,
- * and calls the original target.
- *
- * The type of the new method handle will drop the types for the bound
- * parameters from the original target type, since the new method handle
- * will no longer require those arguments to be supplied by its callers.
- *
- * Each given argument object must match the corresponding bound parameter type.
- * If a bound parameter type is a primitive, the argument object
- * must be a wrapper, and will be unboxed to produce the primitive value.
- *
- * The {@code pos} argument selects which parameters are to be bound.
- * It may range between zero and N-L (inclusively),
- * where N is the arity of the target method handle
- * and L is the length of the values array.
- * @param target the method handle to invoke after the argument is inserted
- * @param pos where to insert the argument (zero for the first)
- * @param values the series of arguments to insert
- * @return a method handle which inserts an additional argument,
- * before calling the original method handle
- * @throws NullPointerException if the target or the {@code values} array is null
- * @see MethodHandle#bindTo
- */
- public static
- MethodHandle insertArguments(MethodHandle target, int pos, Object... values) {
- int insCount = values.length;
- MethodType oldType = target.type();
- int outargs = oldType.parameterCount();
- int inargs = outargs - insCount;
- if (inargs < 0)
- throw newIllegalArgumentException("too many values to insert");
- if (pos < 0 || pos > inargs)
- throw newIllegalArgumentException("no argument type to append");
- MethodHandle result = target;
- for (int i = 0; i < insCount; i++) {
- Object value = values[i];
- Class ptype = oldType.parameterType(pos+i);
- if (ptype.isPrimitive()) {
- char btype = 'I';
- Wrapper w = Wrapper.forPrimitiveType(ptype);
- switch (w) {
- case LONG: btype = 'J'; break;
- case FLOAT: btype = 'F'; break;
- case DOUBLE: btype = 'D'; break;
- }
- // perform unboxing and/or primitive conversion
- value = w.convert(value, ptype);
- result = result.bindArgument(pos, btype, value);
- continue;
- }
- value = ptype.cast(value); // throw CCE if needed
- if (pos == 0) {
- result = result.bindReceiver(value);
- } else {
- result = result.bindArgument(pos, 'L', value);
- }
- }
- return result;
- }
-
- /**
- * Produces a method handle which will discard some dummy arguments
- * before calling some other specified target method handle.
- * The type of the new method handle will be the same as the target's type,
- * except it will also include the dummy argument types,
- * at some given position.
- *
- * The {@code pos} argument may range between zero and N,
- * where N is the arity of the target.
- * If {@code pos} is zero, the dummy arguments will precede
- * the target's real arguments; if {@code pos} is N
- * they will come after.
- *
- * Example:
- *
- * This method is also equivalent to the following code:
- *
- * The {@code pos} argument may range between zero and N,
- * where N is the arity of the target.
- * If {@code pos} is zero, the dummy arguments will precede
- * the target's real arguments; if {@code pos} is N
- * they will come after.
- *
- * Example:
- *
- * This method is also equivalent to the following code:
- *
- * The pre-processing is performed by one or more method handles,
- * specified in the elements of the {@code filters} array.
- * The first element of the filter array corresponds to the {@code pos}
- * argument of the target, and so on in sequence.
- *
- * Null arguments in the array are treated as identity functions,
- * and the corresponding arguments left unchanged.
- * (If there are no non-null elements in the array, the original target is returned.)
- * Each filter is applied to the corresponding argument of the adapter.
- *
- * If a filter {@code F} applies to the {@code N}th argument of
- * the target, then {@code F} must be a method handle which
- * takes exactly one argument. The type of {@code F}'s sole argument
- * replaces the corresponding argument type of the target
- * in the resulting adapted method handle.
- * The return type of {@code F} must be identical to the corresponding
- * parameter type of the target.
- *
- * It is an error if there are elements of {@code filters}
- * (null or not)
- * which do not correspond to argument positions in the target.
- * Example:
- * Here is pseudocode for the resulting adapter:
- *
- * If the filter returns a value, the target must accept that value as
- * its argument in position {@code pos}, preceded and/or followed by
- * any arguments not passed to the filter.
- * If the filter returns void, the target must accept all arguments
- * not passed to the filter.
- * No arguments are reordered, and a result returned from the filter
- * replaces (in order) the whole subsequence of arguments originally
- * passed to the adapter.
- *
- * The argument types (if any) of the filter
- * replace zero or one argument types of the target, at position {@code pos},
- * in the resulting adapted method handle.
- * The return type of the filter (if any) must be identical to the
- * argument type of the target at position {@code pos}, and that target argument
- * is supplied by the return value of the filter.
- *
- * In all cases, {@code pos} must be greater than or equal to zero, and
- * {@code pos} must also be less than or equal to the target's arity.
- * Example:
- * Here is pseudocode for the resulting adapter:
- *
- * A collection adapter {@code collectArguments(mh, 0, coll)} is equivalent to
- * one which first "folds" the affected arguments, and then drops them, in separate
- * steps as follows:
- *
- * If the target returns a value, the filter must accept that value as
- * its only argument.
- * If the target returns void, the filter must accept no arguments.
- *
- * The return type of the filter
- * replaces the return type of the target
- * in the resulting adapted method handle.
- * The argument type of the filter (if any) must be identical to the
- * return type of the target.
- * Example:
- * Here is pseudocode for the resulting adapter:
- *
- * The pre-processing is performed by {@code combiner}, a second method handle.
- * Of the arguments passed to the adapter, the first {@code N} arguments
- * are copied to the combiner, which is then called.
- * (Here, {@code N} is defined as the parameter count of the combiner.)
- * After this, control passes to the target, with any result
- * from the combiner inserted before the original {@code N} incoming
- * arguments.
- *
- * If the combiner returns a value, the first parameter type of the target
- * must be identical with the return type of the combiner, and the next
- * {@code N} parameter types of the target must exactly match the parameters
- * of the combiner.
- *
- * If the combiner has a void return, no result will be inserted,
- * and the first {@code N} parameter types of the target
- * must exactly match the parameters of the combiner.
- *
- * The resulting adapter is the same type as the target, except that the
- * first parameter type is dropped,
- * if it corresponds to the result of the combiner.
- *
- * (Note that {@link #dropArguments(MethodHandle,int,List) dropArguments} can be used to remove any arguments
- * that either the combiner or the target does not wish to receive.
- * If some of the incoming arguments are destined only for the combiner,
- * consider using {@link MethodHandle#asCollector asCollector} instead, since those
- * arguments will not need to be live on the stack on entry to the
- * target.)
- * Example:
- * Here is pseudocode for the resulting adapter:
- * Here is pseudocode for the resulting adapter:
- *
- * The target and handler must have the same corresponding
- * argument and return types, except that handler may omit trailing arguments
- * (similarly to the predicate in {@link #guardWithTest guardWithTest}).
- * Also, the handler must have an extra leading parameter of {@code exType} or a supertype.
- * Here is pseudocode for the resulting adapter:
- *
- * The target and handler must return the same type, even if the handler
- * always throws. (This might happen, for instance, because the handler
- * is simulating a {@code finally} clause).
- * To create such a throwing handler, compose the handler creation logic
- * with {@link #throwException throwException},
- * in order to create a method handle of the correct return type.
- * @param target method handle to call
- * @param exType the type of exception which the handler will catch
- * @param handler method handle to call if a matching exception is thrown
- * @return method handle which incorporates the specified try/catch logic
- * @throws NullPointerException if any argument is null
- * @throws IllegalArgumentException if {@code handler} does not accept
- * the given exception type, or if the method handle types do
- * not match in their return types and their
- * corresponding parameters
- */
- public static
- MethodHandle catchException(MethodHandle target,
- Class exType,
- MethodHandle handler) {
- MethodType ttype = target.type();
- MethodType htype = handler.type();
- if (htype.parameterCount() < 1 ||
- !htype.parameterType(0).isAssignableFrom(exType))
- throw newIllegalArgumentException("handler does not accept exception type "+exType);
- if (htype.returnType() != ttype.returnType())
- throw misMatchedTypes("target and handler return types", ttype, htype);
- ListLookup Factory Methods
- * The factory methods on a {@code Lookup} object correspond to all major
- * use cases for methods, constructors, and fields.
- * Each method handle created by a factory method is the functional
- * equivalent of a particular bytecode behavior.
- * (Bytecode behaviors are described in section 5.4.3.5 of the Java Virtual Machine Specification.)
- * Here is a summary of the correspondence between these factory methods and
- * the behavior the resulting method handles:
- *
- *
- *
- * Access checking
- * Access checks are applied in the factory methods of {@code Lookup},
- * when a method handle is created.
- * This is a key difference from the Core Reflection API, since
- * {@link java.lang.reflect.Method#invoke java.lang.reflect.Method.invoke}
- * performs access checking against every caller, on every call.
- *
- *
- *
- *
- * Security manager interactions
- * Although bytecode instructions can only refer to classes in
- * a related class loader, this API can search for methods in any
- * class, as long as a reference to its {@code Class} object is
- * available. Such cross-loader references are also possible with the
- * Core Reflection API, and are impossible to bytecode instructions
- * such as {@code invokestatic} or {@code getfield}.
- * There is a {@linkplain java.lang.SecurityManager security manager API}
- * to allow applications to check such cross-loader references.
- * These checks apply to both the {@code MethodHandles.Lookup} API
- * and the Core Reflection API
- * (as found on {@link java.lang.Class Class}).
- *
- *
- * Security checks are performed after other access checks have passed.
- * Therefore, the above rules presuppose a member that is public,
- * or else that is being accessed from a lookup class that has
- * rights to access the member.
- *
- * Caller sensitive methods
- * A small number of Java methods have a special property called caller sensitivity.
- * A caller-sensitive method can behave differently depending on the
- * identity of its immediate caller.
- *
- *
- *
- * @param requestedLookupClass the desired lookup class for the new lookup object
- * @return a lookup object which reports the desired lookup class
- * @throws NullPointerException if the argument is null
- */
- public Lookup in(Class requestedLookupClass) {
- requestedLookupClass.getClass(); // null check
- if (allowedModes == TRUSTED) // IMPL_LOOKUP can make any lookup at all
- return new Lookup(requestedLookupClass, ALL_MODES);
- if (requestedLookupClass == this.lookupClass)
- return this; // keep same capabilities
- int newModes = (allowedModes & (ALL_MODES & ~PROTECTED));
- if ((newModes & PACKAGE) != 0
- && !VerifyAccess.isSamePackage(this.lookupClass, requestedLookupClass)) {
- newModes &= ~(PACKAGE|PRIVATE);
- }
- // Allow nestmate lookups to be created without special privilege:
- if ((newModes & PRIVATE) != 0
- && !VerifyAccess.isSamePackageMember(this.lookupClass, requestedLookupClass)) {
- newModes &= ~PRIVATE;
- }
- if ((newModes & PUBLIC) != 0
- && !VerifyAccess.isClassAccessible(requestedLookupClass, this.lookupClass, allowedModes)) {
- // The requested class it not accessible from the lookup class.
- // No permissions.
- newModes = 0;
- }
- checkUnprivilegedlookupClass(requestedLookupClass, newModes);
- return new Lookup(requestedLookupClass, newModes);
- }
-
- // Make sure outer class is initialized first.
- static { IMPL_NAMES.getClass(); }
-
- /** Version of lookup which is trusted minimally.
- * It can only be used to create method handles to
- * publicly accessible members.
- */
- static final Lookup PUBLIC_LOOKUP = new Lookup(Object.class, PUBLIC);
-
- /** Package-private version of lookup which is trusted. */
- static final Lookup IMPL_LOOKUP = new Lookup(Object.class, TRUSTED);
-
- private static void checkUnprivilegedlookupClass(Class lookupClass, int allowedModes) {
- String name = lookupClass.getName();
- if (name.startsWith("java.lang.invoke."))
- throw newIllegalArgumentException("illegal lookupClass: "+lookupClass);
-
- // For caller-sensitive MethodHandles.lookup()
- // disallow lookup more restricted packages
- if (allowedModes == ALL_MODES && lookupClass.getClassLoader() == null) {
- if (name.startsWith("java.") ||
- (name.startsWith("sun.") && !name.startsWith("sun.invoke."))) {
- throw newIllegalArgumentException("illegal lookupClass: " + lookupClass);
- }
- }
- }
-
- /**
- * Displays the name of the class from which lookups are to be made.
- * (The name is the one reported by {@link java.lang.Class#getName() Class.getName}.)
- * If there are restrictions on the access permitted to this lookup,
- * this is indicated by adding a suffix to the class name, consisting
- * of a slash and a keyword. The keyword represents the strongest
- * allowed access, and is chosen as follows:
- *
- *
- * If none of the above cases apply, it is the case that full
- * access (public, package, private, and protected) is allowed.
- * In this case, no suffix is added.
- * This is true only of an object obtained originally from
- * {@link java.lang.invoke.MethodHandles#lookup MethodHandles.lookup}.
- * Objects created by {@link java.lang.invoke.MethodHandles.Lookup#in Lookup.in}
- * always have restricted access, and will display a suffix.
- *
- * @param refc the class from which the method is accessed
- * @param name the name of the method
- * @param type the type of the method
- * @return the desired method handle
- * @throws NoSuchMethodException if the method does not exist
- * @throws IllegalAccessException if access checking fails,
- * or if the method is not {@code static},
- * or if the method's variable arity modifier bit
- * is set and {@code asVarargsCollector} fails
- * @exception SecurityException if a security manager is present and it
- * refuses access
- * @throws NullPointerException if any argument is null
- */
- public
- MethodHandle findStatic(Class refc, String name, MethodType type) throws NoSuchMethodException, IllegalAccessException {
- MemberName method = resolveOrFail(REF_invokeStatic, refc, name, type);
- return getDirectMethod(REF_invokeStatic, refc, method, findBoundCallerClass(method));
- }
-
- /**
- * Produces a method handle for a virtual method.
- * The type of the method handle will be that of the method,
- * with the receiver type (usually {@code refc}) prepended.
- * The method and all its argument types must be accessible to the lookup object.
- * {@code
-import static java.lang.invoke.MethodHandles.*;
-import static java.lang.invoke.MethodType.*;
-...
-MethodHandle MH_asList = publicLookup().findStatic(Arrays.class,
- "asList", methodType(List.class, Object[].class));
-assertEquals("[x, y]", MH_asList.invoke("x", "y").toString());
- * }
- *
- * @param refc the class or interface from which the method is accessed
- * @param name the name of the method
- * @param type the type of the method, with the receiver argument omitted
- * @return the desired method handle
- * @throws NoSuchMethodException if the method does not exist
- * @throws IllegalAccessException if access checking fails,
- * or if the method is {@code static}
- * or if the method's variable arity modifier bit
- * is set and {@code asVarargsCollector} fails
- * @exception SecurityException if a security manager is present and it
- * refuses access
- * @throws NullPointerException if any argument is null
- */
- public MethodHandle findVirtual(Class refc, String name, MethodType type) throws NoSuchMethodException, IllegalAccessException {
- if (refc == MethodHandle.class) {
- MethodHandle mh = findVirtualForMH(name, type);
- if (mh != null) return mh;
- }
- byte refKind = (refc.isInterface() ? REF_invokeInterface : REF_invokeVirtual);
- MemberName method = resolveOrFail(refKind, refc, name, type);
- return getDirectMethod(refKind, refc, method, findBoundCallerClass(method));
- }
- private MethodHandle findVirtualForMH(String name, MethodType type) {
- // these names require special lookups because of the implicit MethodType argument
- if ("invoke".equals(name))
- return invoker(type);
- if ("invokeExact".equals(name))
- return exactInvoker(type);
- assert(!MemberName.isMethodHandleInvokeName(name));
- return null;
- }
-
- /**
- * Produces a method handle which creates an object and initializes it, using
- * the constructor of the specified type.
- * The parameter types of the method handle will be those of the constructor,
- * while the return type will be a reference to the constructor's class.
- * The constructor and all its argument types must be accessible to the lookup object.
- * {@code
-import static java.lang.invoke.MethodHandles.*;
-import static java.lang.invoke.MethodType.*;
-...
-MethodHandle MH_concat = publicLookup().findVirtual(String.class,
- "concat", methodType(String.class, String.class));
-MethodHandle MH_hashCode = publicLookup().findVirtual(Object.class,
- "hashCode", methodType(int.class));
-MethodHandle MH_hashCode_String = publicLookup().findVirtual(String.class,
- "hashCode", methodType(int.class));
-assertEquals("xy", (String) MH_concat.invokeExact("x", "y"));
-assertEquals("xy".hashCode(), (int) MH_hashCode.invokeExact((Object)"xy"));
-assertEquals("xy".hashCode(), (int) MH_hashCode_String.invokeExact("xy"));
-// interface method:
-MethodHandle MH_subSequence = publicLookup().findVirtual(CharSequence.class,
- "subSequence", methodType(CharSequence.class, int.class, int.class));
-assertEquals("def", MH_subSequence.invoke("abcdefghi", 3, 6).toString());
-// constructor "internal method" must be accessed differently:
-MethodType MT_newString = methodType(void.class); //()V for new String()
-try { assertEquals("impossible", lookup()
- .findVirtual(String.class, "
- * @param refc the class or interface from which the method is accessed
- * @param type the type of the method, with the receiver argument omitted, and a void return type
- * @return the desired method handle
- * @throws NoSuchMethodException if the constructor does not exist
- * @throws IllegalAccessException if access checking fails
- * or if the method's variable arity modifier bit
- * is set and {@code asVarargsCollector} fails
- * @exception SecurityException if a security manager is present and it
- * refuses access
- * @throws NullPointerException if any argument is null
- */
- public MethodHandle findConstructor(Class refc, MethodType type) throws NoSuchMethodException, IllegalAccessException {
- String name = "{@code
-import static java.lang.invoke.MethodHandles.*;
-import static java.lang.invoke.MethodType.*;
-...
-MethodHandle MH_newArrayList = publicLookup().findConstructor(
- ArrayList.class, methodType(void.class, Collection.class));
-Collection orig = Arrays.asList("x", "y");
-Collection copy = (ArrayList) MH_newArrayList.invokeExact(orig);
-assert(orig != copy);
-assertEquals(orig, copy);
-// a variable-arity constructor:
-MethodHandle MH_newProcessBuilder = publicLookup().findConstructor(
- ProcessBuilder.class, methodType(void.class, String[].class));
-ProcessBuilder pb = (ProcessBuilder)
- MH_newProcessBuilder.invoke("x", "y", "z");
-assertEquals("[x, y, z]", pb.command().toString());
- * }
- *
- * @param refc the class or interface from which the method is accessed
- * @param name the name of the method (which must not be "<init>")
- * @param type the type of the method, with the receiver argument omitted
- * @param specialCaller the proposed calling class to perform the {@code invokespecial}
- * @return the desired method handle
- * @throws NoSuchMethodException if the method does not exist
- * @throws IllegalAccessException if access checking fails
- * or if the method's variable arity modifier bit
- * is set and {@code asVarargsCollector} fails
- * @exception SecurityException if a security manager is present and it
- * refuses access
- * @throws NullPointerException if any argument is null
- */
- public MethodHandle findSpecial(Class refc, String name, MethodType type,
- Class specialCaller) throws NoSuchMethodException, IllegalAccessException {
- checkSpecialCaller(specialCaller);
- Lookup specialLookup = this.in(specialCaller);
- MemberName method = specialLookup.resolveOrFail(REF_invokeSpecial, refc, name, type);
- return specialLookup.getDirectMethod(REF_invokeSpecial, refc, method, findBoundCallerClass(method));
- }
-
- /**
- * Produces a method handle giving read access to a non-static field.
- * The type of the method handle will have a return type of the field's
- * value type.
- * The method handle's single argument will be the instance containing
- * the field.
- * Access checking is performed immediately on behalf of the lookup class.
- * @param refc the class or interface from which the method is accessed
- * @param name the field's name
- * @param type the field's type
- * @return a method handle which can load values from the field
- * @throws NoSuchFieldException if the field does not exist
- * @throws IllegalAccessException if access checking fails, or if the field is {@code static}
- * @exception SecurityException if a security manager is present and it
- * refuses access
- * @throws NullPointerException if any argument is null
- */
- public MethodHandle findGetter(Class refc, String name, Class type) throws NoSuchFieldException, IllegalAccessException {
- MemberName field = resolveOrFail(REF_getField, refc, name, type);
- return getDirectField(REF_getField, refc, field);
- }
-
- /**
- * Produces a method handle giving write access to a non-static field.
- * The type of the method handle will have a void return type.
- * The method handle will take two arguments, the instance containing
- * the field, and the value to be stored.
- * The second argument will be of the field's value type.
- * Access checking is performed immediately on behalf of the lookup class.
- * @param refc the class or interface from which the method is accessed
- * @param name the field's name
- * @param type the field's type
- * @return a method handle which can store values into the field
- * @throws NoSuchFieldException if the field does not exist
- * @throws IllegalAccessException if access checking fails, or if the field is {@code static}
- * @exception SecurityException if a security manager is present and it
- * refuses access
- * @throws NullPointerException if any argument is null
- */
- public MethodHandle findSetter(Class refc, String name, Class type) throws NoSuchFieldException, IllegalAccessException {
- MemberName field = resolveOrFail(REF_putField, refc, name, type);
- return getDirectField(REF_putField, refc, field);
- }
-
- /**
- * Produces a method handle giving read access to a static field.
- * The type of the method handle will have a return type of the field's
- * value type.
- * The method handle will take no arguments.
- * Access checking is performed immediately on behalf of the lookup class.
- * {@code
-import static java.lang.invoke.MethodHandles.*;
-import static java.lang.invoke.MethodType.*;
-...
-static class Listie extends ArrayList {
- public String toString() { return "[wee Listie]"; }
- static Lookup lookup() { return MethodHandles.lookup(); }
-}
-...
-// no access to constructor via invokeSpecial:
-MethodHandle MH_newListie = Listie.lookup()
- .findConstructor(Listie.class, methodType(void.class));
-Listie l = (Listie) MH_newListie.invokeExact();
-try { assertEquals("impossible", Listie.lookup().findSpecial(
- Listie.class, "
- * where {@code defc} is either {@code receiver.getClass()} or a super
- * type of that class, in which the requested method is accessible
- * to the lookup class.
- * (Note that {@code bindTo} does not preserve variable arity.)
- * @param receiver the object from which the method is accessed
- * @param name the name of the method
- * @param type the type of the method, with the receiver argument omitted
- * @return the desired method handle
- * @throws NoSuchMethodException if the method does not exist
- * @throws IllegalAccessException if access checking fails
- * or if the method's variable arity modifier bit
- * is set and {@code asVarargsCollector} fails
- * @exception SecurityException if a security manager is present and it
- * refuses access
- * @throws NullPointerException if any argument is null
- * @see MethodHandle#bindTo
- * @see #findVirtual
- */
- public MethodHandle bind(Object receiver, String name, MethodType type) throws NoSuchMethodException, IllegalAccessException {
- Class refc = receiver.getClass(); // may get NPE
- MemberName method = resolveOrFail(REF_invokeSpecial, refc, name, type);
- MethodHandle mh = getDirectMethodNoRestrict(REF_invokeSpecial, refc, method, findBoundCallerClass(method));
- return mh.bindReceiver(receiver).setVarargs(method);
- }
-
- /**
- * Makes a direct method handle
- * to m, if the lookup class has permission.
- * If m is non-static, the receiver argument is treated as an initial argument.
- * If m is virtual, overriding is respected on every call.
- * Unlike the Core Reflection API, exceptions are not wrapped.
- * The type of the method handle will be that of the method,
- * with the receiver type prepended (but only if it is non-static).
- * If the method's {@code accessible} flag is not set,
- * access checking is performed immediately on behalf of the lookup class.
- * If m is not public, do not share the resulting handle with untrusted parties.
- * {@code
-import static java.lang.invoke.MethodHandles.*;
-import static java.lang.invoke.MethodType.*;
-...
-MethodHandle mh0 = lookup().findVirtual(defc, name, type);
-MethodHandle mh1 = mh0.bindTo(receiver);
-MethodType mt1 = mh1.type();
-if (mh0.isVarargsCollector())
- mh1 = mh1.asVarargsCollector(mt1.parameterType(mt1.parameterCount()-1));
-return mh1;
- * }
- *
- *
- * This method throws no reflective or security exceptions.
- * @param type the desired target type
- * @param leadingArgCount number of fixed arguments, to be passed unchanged to the target
- * @return a method handle suitable for invoking any method handle of the given type
- * @throws NullPointerException if {@code type} is null
- * @throws IllegalArgumentException if {@code leadingArgCount} is not in
- * the range from 0 to {@code type.parameterCount()} inclusive,
- * or if the resulting method handle's type would have
- * too many parameters
- */
- static public
- MethodHandle spreadInvoker(MethodType type, int leadingArgCount) {
- if (leadingArgCount < 0 || leadingArgCount > type.parameterCount())
- throw new IllegalArgumentException("bad argument count "+leadingArgCount);
- return type.invokers().spreadInvoker(leadingArgCount);
- }
-
- /**
- * Produces a special invoker method handle which can be used to
- * invoke any method handle of the given type, as if by {@link MethodHandle#invokeExact invokeExact}.
- * The resulting invoker will have a type which is
- * exactly equal to the desired type, except that it will accept
- * an additional leading argument of type {@code MethodHandle}.
- * {@code
-MethodHandle invoker = MethodHandles.invoker(type);
-int spreadArgCount = type.parameterCount() - leadingArgCount;
-invoker = invoker.asSpreader(Object[].class, spreadArgCount);
-return invoker;
- * }
- *
- * @param target the method handle to invoke after arguments are retyped
- * @param newType the expected type of the new method handle
- * @return a method handle which delegates to the target after performing
- * any necessary argument conversions, and arranges for any
- * necessary return value conversions
- * @throws NullPointerException if either argument is null
- * @throws WrongMethodTypeException if the conversion cannot be made
- * @see MethodHandle#asType
- */
- public static
- MethodHandle explicitCastArguments(MethodHandle target, MethodType newType) {
- if (!target.type().isCastableTo(newType)) {
- throw new WrongMethodTypeException("cannot explicitly cast "+target+" to "+newType);
- }
- return MethodHandleImpl.makePairwiseConvert(target, newType, 2);
- }
-
- /**
- * Produces a method handle which adapts the calling sequence of the
- * given method handle to a new type, by reordering the arguments.
- * The resulting method handle is guaranteed to report a type
- * which is equal to the desired new type.
- *
- * @param target the method handle to invoke after arguments are reordered
- * @param newType the expected type of the new method handle
- * @param reorder an index array which controls the reordering
- * @return a method handle which delegates to the target after it
- * drops unused arguments and moves and/or duplicates the other arguments
- * @throws NullPointerException if any argument is null
- * @throws IllegalArgumentException if the index array length is not equal to
- * the arity of the target, or if any index array element
- * not a valid index for a parameter of {@code newType},
- * or if two corresponding parameter types in
- * {@code target.type()} and {@code newType} are not identical,
- */
- public static
- MethodHandle permuteArguments(MethodHandle target, MethodType newType, int... reorder) {
- checkReorder(reorder, newType, target.type());
- return target.permuteArguments(newType, reorder);
- }
-
- private static void checkReorder(int[] reorder, MethodType newType, MethodType oldType) {
- if (newType.returnType() != oldType.returnType())
- throw newIllegalArgumentException("return types do not match",
- oldType, newType);
- if (reorder.length == oldType.parameterCount()) {
- int limit = newType.parameterCount();
- boolean bad = false;
- for (int j = 0; j < reorder.length; j++) {
- int i = reorder[j];
- if (i < 0 || i >= limit) {
- bad = true; break;
- }
- Class src = newType.parameterType(i);
- Class dst = oldType.parameterType(j);
- if (src != dst)
- throw newIllegalArgumentException("parameter types do not match after reorder",
- oldType, newType);
- }
- if (!bad) return;
- }
- throw newIllegalArgumentException("bad reorder array: "+Arrays.toString(reorder));
- }
-
- /**
- * Produces a method handle of the requested return type which returns the given
- * constant value every time it is invoked.
- * {@code
-import static java.lang.invoke.MethodHandles.*;
-import static java.lang.invoke.MethodType.*;
-...
-MethodType intfn1 = methodType(int.class, int.class);
-MethodType intfn2 = methodType(int.class, int.class, int.class);
-MethodHandle sub = ... (int x, int y) -> (x-y) ...;
-assert(sub.type().equals(intfn2));
-MethodHandle sub1 = permuteArguments(sub, intfn2, 0, 1);
-MethodHandle rsub = permuteArguments(sub, intfn2, 1, 0);
-assert((int)rsub.invokeExact(1, 100) == 99);
-MethodHandle add = ... (int x, int y) -> (x+y) ...;
-assert(add.type().equals(intfn2));
-MethodHandle twice = permuteArguments(add, intfn1, 0, 0);
-assert(twice.type().equals(intfn1));
-assert((int)twice.invokeExact(21) == 42);
- * }
- * {@code
-import static java.lang.invoke.MethodHandles.*;
-import static java.lang.invoke.MethodType.*;
-...
-MethodHandle cat = lookup().findVirtual(String.class,
- "concat", methodType(String.class, String.class));
-assertEquals("xy", (String) cat.invokeExact("x", "y"));
-MethodType bigType = cat.type().insertParameterTypes(0, int.class, String.class);
-MethodHandle d0 = dropArguments(cat, 0, bigType.parameterList().subList(0,2));
-assertEquals(bigType, d0.type());
-assertEquals("yz", (String) d0.invokeExact(123, "x", "y", "z"));
- * }
- * @param target the method handle to invoke after the arguments are dropped
- * @param valueTypes the type(s) of the argument(s) to drop
- * @param pos position of first argument to drop (zero for the leftmost)
- * @return a method handle which drops arguments of the given types,
- * before calling the original method handle
- * @throws NullPointerException if the target is null,
- * or if the {@code valueTypes} list or any of its elements is null
- * @throws IllegalArgumentException if any element of {@code valueTypes} is {@code void.class},
- * or if {@code pos} is negative or greater than the arity of the target,
- * or if the new method handle's type would have too many parameters
- */
- public static
- MethodHandle dropArguments(MethodHandle target, int pos, List
- * {@link #dropArguments(MethodHandle,int,Class...) dropArguments}{@code (target, pos, valueTypes.toArray(new Class[0]))}
- *
- * {@code
-import static java.lang.invoke.MethodHandles.*;
-import static java.lang.invoke.MethodType.*;
-...
-MethodHandle cat = lookup().findVirtual(String.class,
- "concat", methodType(String.class, String.class));
-assertEquals("xy", (String) cat.invokeExact("x", "y"));
-MethodHandle d0 = dropArguments(cat, 0, String.class);
-assertEquals("yz", (String) d0.invokeExact("x", "y", "z"));
-MethodHandle d1 = dropArguments(cat, 1, String.class);
-assertEquals("xz", (String) d1.invokeExact("x", "y", "z"));
-MethodHandle d2 = dropArguments(cat, 2, String.class);
-assertEquals("xy", (String) d2.invokeExact("x", "y", "z"));
-MethodHandle d12 = dropArguments(cat, 1, int.class, boolean.class);
-assertEquals("xz", (String) d12.invokeExact("x", 12, true, "z"));
- * }
- * @param target the method handle to invoke after the arguments are dropped
- * @param valueTypes the type(s) of the argument(s) to drop
- * @param pos position of first argument to drop (zero for the leftmost)
- * @return a method handle which drops arguments of the given types,
- * before calling the original method handle
- * @throws NullPointerException if the target is null,
- * or if the {@code valueTypes} array or any of its elements is null
- * @throws IllegalArgumentException if any element of {@code valueTypes} is {@code void.class},
- * or if {@code pos} is negative or greater than the arity of the target,
- * or if the new method handle's type would have
- * too many parameters
- */
- public static
- MethodHandle dropArguments(MethodHandle target, int pos, Class... valueTypes) {
- return dropArguments(target, pos, Arrays.asList(valueTypes));
- }
-
- /**
- * Adapts a target method handle by pre-processing
- * one or more of its arguments, each with its own unary filter function,
- * and then calling the target with each pre-processed argument
- * replaced by the result of its corresponding filter function.
- *
- * {@link #dropArguments(MethodHandle,int,List) dropArguments}{@code (target, pos, Arrays.asList(valueTypes))}
- *
- * {@code
-import static java.lang.invoke.MethodHandles.*;
-import static java.lang.invoke.MethodType.*;
-...
-MethodHandle cat = lookup().findVirtual(String.class,
- "concat", methodType(String.class, String.class));
-MethodHandle upcase = lookup().findVirtual(String.class,
- "toUpperCase", methodType(String.class));
-assertEquals("xy", (String) cat.invokeExact("x", "y"));
-MethodHandle f0 = filterArguments(cat, 0, upcase);
-assertEquals("Xy", (String) f0.invokeExact("x", "y")); // Xy
-MethodHandle f1 = filterArguments(cat, 1, upcase);
-assertEquals("xY", (String) f1.invokeExact("x", "y")); // xY
-MethodHandle f2 = filterArguments(cat, 0, upcase, upcase);
-assertEquals("XY", (String) f2.invokeExact("x", "y")); // XY
- * }
- *
- * @param target the method handle to invoke after arguments are filtered
- * @param pos the position of the first argument to filter
- * @param filters method handles to call initially on filtered arguments
- * @return method handle which incorporates the specified argument filtering logic
- * @throws NullPointerException if the target is null
- * or if the {@code filters} array is null
- * @throws IllegalArgumentException if a non-null element of {@code filters}
- * does not match a corresponding argument type of target as described above,
- * or if the {@code pos+filters.length} is greater than {@code target.type().parameterCount()},
- * or if the resulting method handle's type would have
- * too many parameters
- */
- public static
- MethodHandle filterArguments(MethodHandle target, int pos, MethodHandle... filters) {
- MethodType targetType = target.type();
- MethodHandle adapter = target;
- MethodType adapterType = null;
- assert((adapterType = targetType) != null);
- int maxPos = targetType.parameterCount();
- if (pos + filters.length > maxPos)
- throw newIllegalArgumentException("too many filters");
- int curPos = pos-1; // pre-incremented
- for (MethodHandle filter : filters) {
- curPos += 1;
- if (filter == null) continue; // ignore null elements of filters
- adapter = filterArgument(adapter, curPos, filter);
- assert((adapterType = adapterType.changeParameterType(curPos, filter.type().parameterType(0))) != null);
- }
- assert(adapterType.equals(adapter.type()));
- return adapter;
- }
-
- /*non-public*/ static
- MethodHandle filterArgument(MethodHandle target, int pos, MethodHandle filter) {
- MethodType targetType = target.type();
- MethodType filterType = filter.type();
- if (filterType.parameterCount() != 1
- || filterType.returnType() != targetType.parameterType(pos))
- throw newIllegalArgumentException("target and filter types do not match", targetType, filterType);
- return MethodHandleImpl.makeCollectArguments(target, filter, pos, false);
- }
-
- /**
- * Adapts a target method handle by pre-processing
- * a sub-sequence of its arguments with a filter (another method handle).
- * The pre-processed arguments are replaced by the result (if any) of the
- * filter function.
- * The target is then called on the modified (usually shortened) argument list.
- * {@code
- * V target(P... p, A[i]... a[i], B... b);
- * A[i] filter[i](V[i]);
- * T adapter(P... p, V[i]... v[i], B... b) {
- * return target(p..., f[i](v[i])..., b...);
- * }
- * }
- * {@code
-import static java.lang.invoke.MethodHandles.*;
-import static java.lang.invoke.MethodType.*;
-...
-MethodHandle deepToString = publicLookup()
- .findStatic(Arrays.class, "deepToString", methodType(String.class, Object[].class));
-
-MethodHandle ts1 = deepToString.asCollector(String[].class, 1);
-assertEquals("[strange]", (String) ts1.invokeExact("strange"));
-
-MethodHandle ts2 = deepToString.asCollector(String[].class, 2);
-assertEquals("[up, down]", (String) ts2.invokeExact("up", "down"));
-
-MethodHandle ts3 = deepToString.asCollector(String[].class, 3);
-MethodHandle ts3_ts2 = collectArguments(ts3, 1, ts2);
-assertEquals("[top, [up, down], strange]",
- (String) ts3_ts2.invokeExact("top", "up", "down", "strange"));
-
-MethodHandle ts3_ts2_ts1 = collectArguments(ts3_ts2, 3, ts1);
-assertEquals("[top, [up, down], [strange]]",
- (String) ts3_ts2_ts1.invokeExact("top", "up", "down", "strange"));
-
-MethodHandle ts3_ts2_ts3 = collectArguments(ts3_ts2, 1, ts3);
-assertEquals("[top, [[up, down, strange], charm], bottom]",
- (String) ts3_ts2_ts3.invokeExact("top", "up", "down", "strange", "charm", "bottom"));
- * }
- * {@code
- * T target(A...,V,C...);
- * V filter(B...);
- * T adapter(A... a,B... b,C... c) {
- * V v = filter(b...);
- * return target(a...,v,c...);
- * }
- * // and if the filter has no arguments:
- * T target2(A...,V,C...);
- * V filter2();
- * T adapter2(A... a,C... c) {
- * V v = filter2();
- * return target2(a...,v,c...);
- * }
- * // and if the filter has a void return:
- * T target3(A...,C...);
- * void filter3(B...);
- * void adapter3(A... a,B... b,C... c) {
- * filter3(b...);
- * return target3(a...,c...);
- * }
- * }
- * If the target method handle consumes no arguments besides than the result
- * (if any) of the filter {@code coll}, then {@code collectArguments(mh, 0, coll)}
- * is equivalent to {@code filterReturnValue(coll, mh)}.
- * If the filter method handle {@code coll} consumes one argument and produces
- * a non-void result, then {@code collectArguments(mh, N, coll)}
- * is equivalent to {@code filterArguments(mh, N, coll)}.
- * Other equivalences are possible but would require argument permutation.
- *
- * @param target the method handle to invoke after filtering the subsequence of arguments
- * @param pos the position of the first adapter argument to pass to the filter,
- * and/or the target argument which receives the result of the filter
- * @param filter method handle to call on the subsequence of arguments
- * @return method handle which incorporates the specified argument subsequence filtering logic
- * @throws NullPointerException if either argument is null
- * @throws IllegalArgumentException if the return type of {@code filter}
- * is non-void and is not the same as the {@code pos} argument of the target,
- * or if {@code pos} is not between 0 and the target's arity, inclusive,
- * or if the resulting method handle's type would have
- * too many parameters
- * @see MethodHandles#foldArguments
- * @see MethodHandles#filterArguments
- * @see MethodHandles#filterReturnValue
- */
- public static
- MethodHandle collectArguments(MethodHandle target, int pos, MethodHandle filter) {
- MethodType targetType = target.type();
- MethodType filterType = filter.type();
- if (filterType.returnType() != void.class &&
- filterType.returnType() != targetType.parameterType(pos))
- throw newIllegalArgumentException("target and filter types do not match", targetType, filterType);
- return MethodHandleImpl.makeCollectArguments(target, filter, pos, false);
- }
-
- /**
- * Adapts a target method handle by post-processing
- * its return value (if any) with a filter (another method handle).
- * The result of the filter is returned from the adapter.
- * {@code
- * mh = MethodHandles.dropArguments(mh, 1, coll.type().parameterList()); //step 2
- * mh = MethodHandles.foldArguments(mh, coll); //step 1
- * }
- * {@code
-import static java.lang.invoke.MethodHandles.*;
-import static java.lang.invoke.MethodType.*;
-...
-MethodHandle cat = lookup().findVirtual(String.class,
- "concat", methodType(String.class, String.class));
-MethodHandle length = lookup().findVirtual(String.class,
- "length", methodType(int.class));
-System.out.println((String) cat.invokeExact("x", "y")); // xy
-MethodHandle f0 = filterReturnValue(cat, length);
-System.out.println((int) f0.invokeExact("x", "y")); // 2
- * }
- * @param target the method handle to invoke before filtering the return value
- * @param filter method handle to call on the return value
- * @return method handle which incorporates the specified return value filtering logic
- * @throws NullPointerException if either argument is null
- * @throws IllegalArgumentException if the argument list of {@code filter}
- * does not match the return type of target as described above
- */
- public static
- MethodHandle filterReturnValue(MethodHandle target, MethodHandle filter) {
- MethodType targetType = target.type();
- MethodType filterType = filter.type();
- Class rtype = targetType.returnType();
- int filterValues = filterType.parameterCount();
- if (filterValues == 0
- ? (rtype != void.class)
- : (rtype != filterType.parameterType(0)))
- throw newIllegalArgumentException("target and filter types do not match", target, filter);
- // result = fold( lambda(retval, arg...) { filter(retval) },
- // lambda( arg...) { target(arg...) } )
- return MethodHandleImpl.makeCollectArguments(filter, target, 0, false);
- }
-
- /**
- * Adapts a target method handle by pre-processing
- * some of its arguments, and then calling the target with
- * the result of the pre-processing, inserted into the original
- * sequence of arguments.
- * {@code
- * V target(A...);
- * T filter(V);
- * T adapter(A... a) {
- * V v = target(a...);
- * return filter(v);
- * }
- * // and if the target has a void return:
- * void target2(A...);
- * T filter2();
- * T adapter2(A... a) {
- * target2(a...);
- * return filter2();
- * }
- * // and if the filter has a void return:
- * V target3(A...);
- * void filter3(V);
- * void adapter3(A... a) {
- * V v = target3(a...);
- * filter3(v);
- * }
- * }
- * {@code
-import static java.lang.invoke.MethodHandles.*;
-import static java.lang.invoke.MethodType.*;
-...
-MethodHandle trace = publicLookup().findVirtual(java.io.PrintStream.class,
- "println", methodType(void.class, String.class))
- .bindTo(System.out);
-MethodHandle cat = lookup().findVirtual(String.class,
- "concat", methodType(String.class, String.class));
-assertEquals("boojum", (String) cat.invokeExact("boo", "jum"));
-MethodHandle catTrace = foldArguments(cat, trace);
-// also prints "boo":
-assertEquals("boojum", (String) catTrace.invokeExact("boo", "jum"));
- * }
- * @param target the method handle to invoke after arguments are combined
- * @param combiner method handle to call initially on the incoming arguments
- * @return method handle which incorporates the specified argument folding logic
- * @throws NullPointerException if either argument is null
- * @throws IllegalArgumentException if {@code combiner}'s return type
- * is non-void and not the same as the first argument type of
- * the target, or if the initial {@code N} argument types
- * of the target
- * (skipping one matching the {@code combiner}'s return type)
- * are not identical with the argument types of {@code combiner}
- */
- public static
- MethodHandle foldArguments(MethodHandle target, MethodHandle combiner) {
- int pos = 0;
- MethodType targetType = target.type();
- MethodType combinerType = combiner.type();
- int foldPos = pos;
- int foldArgs = combinerType.parameterCount();
- int foldVals = combinerType.returnType() == void.class ? 0 : 1;
- int afterInsertPos = foldPos + foldVals;
- boolean ok = (targetType.parameterCount() >= afterInsertPos + foldArgs);
- if (ok && !(combinerType.parameterList()
- .equals(targetType.parameterList().subList(afterInsertPos,
- afterInsertPos + foldArgs))))
- ok = false;
- if (ok && foldVals != 0 && !combinerType.returnType().equals(targetType.parameterType(0)))
- ok = false;
- if (!ok)
- throw misMatchedTypes("target and combiner types", targetType, combinerType);
- MethodType newType = targetType.dropParameterTypes(foldPos, afterInsertPos);
- return MethodHandleImpl.makeCollectArguments(target, combiner, foldPos, true);
- }
-
- /**
- * Makes a method handle which adapts a target method handle,
- * by guarding it with a test, a boolean-valued method handle.
- * If the guard fails, a fallback handle is called instead.
- * All three method handles must have the same corresponding
- * argument and return types, except that the return type
- * of the test must be boolean, and the test is allowed
- * to have fewer arguments than the other two method handles.
- * {@code
- * // there are N arguments in A...
- * T target(V, A[N]..., B...);
- * V combiner(A...);
- * T adapter(A... a, B... b) {
- * V v = combiner(a...);
- * return target(v, a..., b...);
- * }
- * // and if the combiner has a void return:
- * T target2(A[N]..., B...);
- * void combiner2(A...);
- * T adapter2(A... a, B... b) {
- * combiner2(a...);
- * return target2(a..., b...);
- * }
- * }
- * Note that the test arguments ({@code a...} in the pseudocode) cannot
- * be modified by execution of the test, and so are passed unchanged
- * from the caller to the target or fallback as appropriate.
- * @param test method handle used for test, must return boolean
- * @param target method handle to call if test passes
- * @param fallback method handle to call if test fails
- * @return method handle which incorporates the specified if/then/else logic
- * @throws NullPointerException if any argument is null
- * @throws IllegalArgumentException if {@code test} does not return boolean,
- * or if all three method types do not match (with the return
- * type of {@code test} changed to match that of the target).
- */
- public static
- MethodHandle guardWithTest(MethodHandle test,
- MethodHandle target,
- MethodHandle fallback) {
- MethodType gtype = test.type();
- MethodType ttype = target.type();
- MethodType ftype = fallback.type();
- if (!ttype.equals(ftype))
- throw misMatchedTypes("target and fallback types", ttype, ftype);
- if (gtype.returnType() != boolean.class)
- throw newIllegalArgumentException("guard type is not a predicate "+gtype);
- List{@code
- * boolean test(A...);
- * T target(A...,B...);
- * T fallback(A...,B...);
- * T adapter(A... a,B... b) {
- * if (test(a...))
- * return target(a..., b...);
- * else
- * return fallback(a..., b...);
- * }
- * }
- * Note that the saved arguments ({@code a...} in the pseudocode) cannot
- * be modified by execution of the target, and so are passed unchanged
- * from the caller to the handler, if the handler is invoked.
- * {@code
- * T target(A..., B...);
- * T handler(ExType, A...);
- * T adapter(A... a, B... b) {
- * try {
- * return target(a..., b...);
- * } catch (ExType ex) {
- * return handler(ex, a...);
- * }
- * }
- * }