* The resulting method handle type will be of the given type, * with a receiver type {@code rcvc} prepended if the member is not static. *
* Access checks are made as of the given caller.
* In particular, if the method is protected and {@code defc} is in a
* different package from the caller, then {@code rcvc} must be
* caller or a subclass.
* @param token Proof that the caller has access to this package.
* @param member Resolved method or constructor to call.
* @param name Name of the desired method.
* @param rcvc Receiver type of desired non-static method (else null)
* @param doDispatch whether the method handle will test the receiver type
* @param caller if not null, access-check relative to this class ????
* @return a direct handle to the matching method
* @throws NoAccessException if the given method cannot be accessed by caller
*/
public static
MethodHandle findMethod(Access token, MemberName method,
boolean doDispatch, Class caller) {
Access.check(token); // only trusted calls
MethodType mtype = method.getMethodType();
if (method.isStatic()) {
doDispatch = false;
} else {
// adjust the advertised receiver type to be exactly the one requested
// (in the case of invokespecial, this will be the calling class)
mtype = mtype.insertParameterType(0, method.getDeclaringClass());
if (method.isConstructor())
doDispatch = true;
}
DirectMethodHandle mh = new DirectMethodHandle(mtype, method, doDispatch, caller);
if (!mh.isValid())
throw newNoAccessException(method, caller);
return mh;
}
public static
MethodHandle accessField(Access token,
MemberName member, boolean isSetter,
Class caller) {
Access.check(token);
// FIXME: Use sun.misc.Unsafe to dig up the dirt on the field.
throw new UnsupportedOperationException("Not yet implemented");
}
public static
MethodHandle accessArrayElement(Access token,
Class arrayClass, boolean isSetter,
Class caller) {
Access.check(token);
if (!arrayClass.isArray())
throw newIllegalArgumentException("not an array: "+arrayClass);
// FIXME: Use sun.misc.Unsafe to dig up the dirt on the array.
throw new UnsupportedOperationException("Not yet implemented");
}
/** Bind a predetermined first argument to the given direct method handle.
* Callable only from MethodHandles.
* @param token Proof that the caller has access to this package.
* @param target Any direct method handle.
* @param receiver Receiver (or first static method argument) to pre-bind.
* @return a BoundMethodHandle for the given DirectMethodHandle, or null if it does not exist
*/
public static
MethodHandle bindReceiver(Access token,
MethodHandle target, Object receiver) {
Access.check(token);
if (target instanceof DirectMethodHandle)
return new BoundMethodHandle((DirectMethodHandle)target, receiver, 0);
return null; // let caller try something else
}
/** Bind a predetermined argument to the given arbitrary method handle.
* Callable only from MethodHandles.
* @param token Proof that the caller has access to this package.
* @param target Any method handle.
* @param receiver Argument (which can be a boxed primitive) to pre-bind.
* @return a suitable BoundMethodHandle
*/
public static
MethodHandle bindArgument(Access token,
MethodHandle target, int argnum, Object receiver) {
Access.check(token);
throw new UnsupportedOperationException("NYI");
}
public static MethodHandle convertArguments(Access token,
MethodHandle target,
MethodType newType, boolean newVarargs,
MethodType oldType, boolean oldVarargs,
String permutationOrNull) {
Access.check(token);
throw new UnsupportedOperationException("Not yet implemented");
}
public static
MethodHandle dropArguments(Access token, MethodHandle target,
MethodType newType, int argnum) {
Access.check(token);
throw new UnsupportedOperationException("NYI");
}
public static
MethodHandle makeGuardWithTest(Access token,
final MethodHandle test,
final MethodHandle target,
final MethodHandle fallback) {
Access.check(token);
// %%% This is just a sketch. It needs to be de-boxed.
// Adjust the handles to accept varargs lists.
MethodType type = target.type();
Class rtype = type.returnType();
if (type.parameterCount() != 1 || type.parameterType(0).isPrimitive()) {
MethodType vatestType = MethodType.make(boolean.class, Object[].class);
MethodType vatargetType = MethodType.make(rtype, Object[].class);
MethodHandle vaguard = makeGuardWithTest(token,
MethodHandles.spreadArguments(test, vatestType),
MethodHandles.spreadArguments(target, vatargetType),
MethodHandles.spreadArguments(fallback, vatargetType));
return MethodHandles.collectArguments(vaguard, type);
}
if (rtype.isPrimitive()) {
MethodType boxtype = type.changeReturnType(Object.class);
MethodHandle boxguard = makeGuardWithTest(token,
test,
MethodHandles.convertArguments(target, boxtype),
MethodHandles.convertArguments(fallback, boxtype));
return MethodHandles.convertArguments(boxguard, type);
}
// Got here? Reduced calling sequence to Object(Object).
final MethodHandleInvoker invoke1
= MethodHandleInvoker.make(test.type());
final MethodHandleInvoker invoke2
= MethodHandleInvoker.make(target.type());
class Guarder {
Object invoke(Object x) {
// If javac supports MethodHandle.invoke directly:
//z = vatest.invoke