src/share/classes/java/lang/invoke/MethodHandleImpl.java

rev 10271 : 8037209: Improvements and cleanups to bytecode assembly for lambda forms
Reviewed-by: vlivanov, psandoz
Contributed-by: john.r.rose@oracle.com
rev 10272 : 8038261: JSR292: cache and reuse typed array accessors
Reviewed-by: vlivanov, psandoz
Contributed-by: john.r.rose@oracle.com
rev 10273 : 8049555: Move varargsArray from sun.invoke.util package to java.lang.invoke
Reviewed-by: ?
rev 10274 : 8050052: Small cleanups in java.lang.invoke code
Reviewed-by: ?
rev 10276 : 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 10277 : 8050173: Add j.l.i.MethodHandle.copyWith(MethodType, LambdaForm)
Reviewed-by: vlivanov, ?
Contributed-by: john.r.rose@oracle.com
rev 10278 : imported patch isInvokeSpecial
rev 10279 : 8050057: Improve caching of MethodHandle reinvokers
Reviewed-by: vlivanov, ?
Contributed-by: john.r.rose@oracle.com

*** 349,381 ****
          MethodType type = target.type();
          int last = type.parameterCount() - 1;
          if (type.parameterType(last) != arrayType)
              target = target.asType(type.changeParameterType(last, arrayType));
          target = target.asFixedArity();  // make sure this attribute is turned off
!         return new AsVarargsCollector(target, target.type(), arrayType);
      }
  
!     static class AsVarargsCollector extends MethodHandle {
          private final MethodHandle target;
          private final Class<?> arrayType;
          private /*@Stable*/ MethodHandle asCollectorCache;
  
!         AsVarargsCollector(MethodHandle target, MethodType type, Class<?> arrayType) {
!             super(type, reinvokerForm(target));
              this.target = target;
              this.arrayType = arrayType;
              this.asCollectorCache = target.asCollector(arrayType, 0);
          }
  
-         @Override MethodHandle reinvokerTarget() { return target; }
- 
          @Override
          public boolean isVarargsCollector() {
              return true;
          }
  
          @Override
          public MethodHandle asFixedArity() {
              return target;
          }
  
          @Override
--- 349,387 ----
          MethodType type = target.type();
          int last = type.parameterCount() - 1;
          if (type.parameterType(last) != arrayType)
              target = target.asType(type.changeParameterType(last, arrayType));
          target = target.asFixedArity();  // make sure this attribute is turned off
!         return new AsVarargsCollector(target, arrayType);
      }
  
!     private static final class AsVarargsCollector extends DelegatingMethodHandle {
          private final MethodHandle target;
          private final Class<?> arrayType;
          private /*@Stable*/ MethodHandle asCollectorCache;
  
!         AsVarargsCollector(MethodHandle target, Class<?> arrayType) {
!             this(target.type(), target, arrayType);
!         }
!         AsVarargsCollector(MethodType type, MethodHandle target, Class<?> arrayType) {
!             super(type, target);
              this.target = target;
              this.arrayType = arrayType;
              this.asCollectorCache = target.asCollector(arrayType, 0);
          }
  
          @Override
          public boolean isVarargsCollector() {
              return true;
          }
  
          @Override
+         protected MethodHandle getTarget() {
+             return target;
+         }
+ 
+         @Override
          public MethodHandle asFixedArity() {
              return target;
          }
  
          @Override
*** 414,449 ****
                      .isAssignableFrom(
                              newType.lastParameterType().getComponentType()))
                      : Arrays.asList(this, newType);
              return true;
          }
- 
-         @Override
-         MethodHandle setVarargs(MemberName member) {
-             if (member.isVarargs())  return this;
-             return asFixedArity();
-         }
- 
-         @Override
-         MemberName internalMemberName() {
-             return asFixedArity().internalMemberName();
-         }
-         @Override
-         Class<?> internalCallerClass() {
-             return asFixedArity().internalCallerClass();
-         }
- 
-         /*non-public*/
-         @Override
-         boolean isInvokeSpecial() {
-             return asFixedArity().isInvokeSpecial();
-         }
- 
-         @Override
-         MethodHandle copyWith(MethodType mt, LambdaForm lf) {
-             throw newIllegalArgumentException("do not use this");
-         }
      }
  
      /** Factory method:  Spread selected argument. */
      static MethodHandle makeSpreadArguments(MethodHandle target,
                                              Class<?> spreadArgType, int spreadArgPos, int spreadArgCount) {
--- 420,429 ----
*** 970,1006 ****
          }
      }
  
  
      /** This subclass allows a wrapped method handle to be re-associated with an arbitrary member name. */
!     static class WrappedMember extends MethodHandle {
          private final MethodHandle target;
          private final MemberName member;
          private final Class<?> callerClass;
          private final boolean isInvokeSpecial;
  
          private WrappedMember(MethodHandle target, MethodType type,
                                MemberName member, boolean isInvokeSpecial,
                                Class<?> callerClass) {
!             super(type, reinvokerForm(target));
              this.target = target;
              this.member = member;
              this.callerClass = callerClass;
              this.isInvokeSpecial = isInvokeSpecial;
          }
  
          @Override
-         MethodHandle reinvokerTarget() {
-             return target;
-         }
-         @Override
-         public MethodHandle asTypeUncached(MethodType newType) {
-             // This MH is an alias for target, except for the MemberName
-             // Drop the MemberName if there is any conversion.
-             return asTypeCache = target.asType(newType);
-         }
-         @Override
          MemberName internalMemberName() {
              return member;
          }
          @Override
          Class<?> internalCallerClass() {
--- 950,976 ----
          }
      }
  
  
      /** This subclass allows a wrapped method handle to be re-associated with an arbitrary member name. */
!     private static final class WrappedMember extends DelegatingMethodHandle {
          private final MethodHandle target;
          private final MemberName member;
          private final Class<?> callerClass;
          private final boolean isInvokeSpecial;
  
          private WrappedMember(MethodHandle target, MethodType type,
                                MemberName member, boolean isInvokeSpecial,
                                Class<?> callerClass) {
!             super(type, target);
              this.target = target;
              this.member = member;
              this.callerClass = callerClass;
              this.isInvokeSpecial = isInvokeSpecial;
          }
  
          @Override
          MemberName internalMemberName() {
              return member;
          }
          @Override
          Class<?> internalCallerClass() {
*** 1008,1021 ****
          }
          @Override
          boolean isInvokeSpecial() {
              return isInvokeSpecial;
          }
- 
          @Override
!         MethodHandle copyWith(MethodType mt, LambdaForm lf) {
!             throw newIllegalArgumentException("do not use this");
          }
      }
  
      static MethodHandle makeWrappedMember(MethodHandle target, MemberName member, boolean isInvokeSpecial) {
          if (member.equals(target.internalMemberName()) && isInvokeSpecial == target.isInvokeSpecial())
--- 978,996 ----
          }
          @Override
          boolean isInvokeSpecial() {
              return isInvokeSpecial;
          }
          @Override
!         protected MethodHandle getTarget() {
!             return target;
!         }
!         @Override
!         public MethodHandle asTypeUncached(MethodType newType) {
!             // This MH is an alias for target, except for the MemberName
!             // Drop the MemberName if there is any conversion.
!             return asTypeCache = target.asType(newType);
          }
      }
  
      static MethodHandle makeWrappedMember(MethodHandle target, MemberName member, boolean isInvokeSpecial) {
          if (member.equals(target.internalMemberName()) && isInvokeSpecial == target.isInvokeSpecial())