*** old/src/share/classes/java/lang/invoke/MethodHandleImpl.java	Mon Jul 14 19:53:29 2014
--- new/src/share/classes/java/lang/invoke/MethodHandleImpl.java	Mon Jul 14 19:53:29 2014

*** 349,381 ****
--- 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, target.type(), arrayType);
      }
  
!     static class AsVarargsCollector extends MethodHandle {
!     private static final class AsVarargsCollector extends DelegatingMethodHandle {
          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.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 MethodHandle reinvokerTarget() { return target; }
  
          @Override
          public boolean isVarargsCollector() {
              return true;
          }
  
          @Override
+         protected MethodHandle getTarget() {
+             return target;
+         }
+ 
+         @Override
          public MethodHandle asFixedArity() {
              return target;
          }
  
          @Override

*** 414,449 ****
--- 420,429 ----
                      .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) {

*** 970,1006 ****
--- 950,976 ----
          }
      }
  
  
      /** This subclass allows a wrapped method handle to be re-associated with an arbitrary member name. */
!     static class WrappedMember extends MethodHandle {
!     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, 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() {

*** 1008,1021 ****
--- 978,996 ----
          }
          @Override
          boolean isInvokeSpecial() {
              return isInvokeSpecial;
          }
  
          @Override
!         MethodHandle copyWith(MethodType mt, LambdaForm lf) {
!             throw newIllegalArgumentException("do not use this");
!         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())