src/java.base/share/classes/java/lang/invoke/MethodHandles.java

rev 10592 : 8050052: Small cleanups in java.lang.invoke code
Reviewed-by: ?
rev 10593 : 8050053: Improve caching of different invokers
Reviewed-by: vlivanov, ?
Contributed-by: john.r.rose@oracle.com
rev 10594 : 8050166: Get rid of some package-private methods on arguments in j.l.i.MethodHandle
Reviewed-by: vlivanov, ?
Contributed-by: john.r.rose@oracle.com
rev 10595 : 8050173: Add j.l.i.MethodHandle.copyWith(MethodType, LambdaForm)
Reviewed-by: vlivanov, ?
Contributed-by: john.r.rose@oracle.com
rev 10596 : [mq]: 07.8050173.viewAsType.1

*** 1577,1598 ****
                  || (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);
              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 {
--- 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));
              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 ****
                  refc = refcAsSuper;
                  // redo basic checks
                  checkMethod(refKind, refc, method);
              }
  
!             MethodHandle mh = DirectMethodHandle.make(refKind, refc, method);
!             mh = maybeBindCaller(method, mh, callerClass);
!             mh = mh.setVarargs(method);
              // Optionally narrow the receiver argument to refc using restrictReceiver.
              if (doRestrict &&
                     (refKind == REF_invokeSpecial ||
                         (MethodHandleNatives.refKindHasReceiver(refKind) &&
!                            restrictProtectedReceiver(method))))
!                 mh = restrictReceiver(method, mh, lookupClass());
              return mh;
          }
          private MethodHandle maybeBindCaller(MemberName method, MethodHandle mh,
                                               Class<?> callerClass)
                                               throws IllegalAccessException {
--- 1650,1670 ----
                  refc = refcAsSuper;
                  // redo basic checks
                  checkMethod(refKind, refc, method);
              }
  
!             DirectMethodHandle dmh = DirectMethodHandle.make(refKind, refc, 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 ****
                                                    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);
!             MethodHandle mh = DirectMethodHandle.make(refc, field);
              boolean doRestrict = (MethodHandleNatives.refKindHasReceiver(refKind) &&
                                      restrictProtectedReceiver(field));
              if (doRestrict)
!                 mh = restrictReceiver(field, mh, lookupClass());
!             return mh;
          }
          /** 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);
--- 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)
!                 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);