+ * 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,
+ MethodType oldType,
+ 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