src/java.base/share/classes/java/lang/invoke/MethodHandles.java
Index
Unified diffs
Context diffs
Sdiffs
Patch
New
Old
Previous File
Next File
*** old/src/java.base/share/classes/java/lang/invoke/MethodHandles.java Fri Sep 5 17:13:19 2014
--- new/src/java.base/share/classes/java/lang/invoke/MethodHandles.java Fri Sep 5 17:13:19 2014
*** 1577,1598 ****
--- 1577,1597 ----
|| (ALLOW_NESTMATE_ACCESS &&
VerifyAccess.isSamePackageMember(method.getDeclaringClass(), lookupClass())))
return false;
return true;
}
! private MethodHandle restrictReceiver(MemberName method, DirectMethodHandle 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);
assert(!mh.isVarargsCollector()); // viewAsType will lose varargs-ness
assert(mh.viewAsTypeChecks(narrowType, true));
assert(mh instanceof DirectMethodHandle); // DirectMethodHandle.copyWith
return mh.copyWith(narrowType, mh.form);
}
/** Check access and get the requested method. */
private MethodHandle getDirectMethod(byte refKind, Class<?> refc, MemberName method, Class<?> callerClass) throws IllegalAccessException {
*** 1651,1669 ****
--- 1650,1670 ----
refc = refcAsSuper;
// redo basic checks
checkMethod(refKind, refc, method);
}
! DirectMethodHandle dmh = DirectMethodHandle.make(refKind, refc, method);
! mh = maybeBindCaller(method, mh, callerClass);
mh = mh.setVarargs(method);
! MethodHandle mh = dmh;
// Optionally narrow the receiver argument to refc using restrictReceiver.
if (doRestrict &&
(refKind == REF_invokeSpecial ||
(MethodHandleNatives.refKindHasReceiver(refKind) &&
! restrictProtectedReceiver(method)))) {
! mh = restrictReceiver(method, dmh, lookupClass());
+ }
+ mh = maybeBindCaller(method, mh, callerClass);
+ mh = mh.setVarargs(method);
return mh;
}
private MethodHandle maybeBindCaller(MemberName method, MethodHandle mh,
Class<?> callerClass)
throws IllegalAccessException {
*** 1691,1706 ****
--- 1692,1707 ----
boolean checkSecurity) throws IllegalAccessException {
checkField(refKind, refc, field);
// Optionally check with the security manager; this isn't needed for unreflect* calls.
if (checkSecurity)
checkSecurityManager(refc, field);
! DirectMethodHandle dmh = DirectMethodHandle.make(refc, field);
boolean doRestrict = (MethodHandleNatives.refKindHasReceiver(refKind) &&
restrictProtectedReceiver(field));
if (doRestrict)
! mh = restrictReceiver(field, mh, lookupClass());
! return mh;
! return restrictReceiver(field, dmh, lookupClass());
! return dmh;
}
/** Check access and get the requested constructor. */
private MethodHandle getDirectConstructor(Class<?> refc, MemberName ctor) throws IllegalAccessException {
final boolean checkSecurity = true;
return getDirectConstructorCommon(refc, ctor, checkSecurity);
src/java.base/share/classes/java/lang/invoke/MethodHandles.java
Index
Unified diffs
Context diffs
Sdiffs
Patch
New
Old
Previous File
Next File