jdk-sandbox: comparison jdk/src/share/classes/java/lang/invoke/MethodHandleImpl.java

equal deleted inserted replaced

-:dabb5e4edc4c
+:5ebbe5ab084f
 MethodType newType = rawConType.dropParameterTypes(0, 1).changeReturnType(allocateClass);
 int nargs = rawConType.parameterCount() - 1;
 if (nargs < INVOKES.length) {
 MethodHandle invoke = INVOKES[nargs];
 MethodType conType = CON_TYPES[nargs];
-MethodHandle gcon = convertArguments(rawConstructor, conType, rawConType, null);
+MethodHandle gcon = convertArguments(rawConstructor, conType, rawConType, 0);
 if (gcon == null)  return null;
 MethodHandle galloc = new AllocateObject(invoke, allocateClass, gcon);
 assert(galloc.type() == newType.generic());
-return convertArguments(galloc, newType, galloc.type(), null);
+return convertArguments(galloc, newType, galloc.type(), 0);
 } else {
 MethodHandle invoke = VARARGS_INVOKE;
 MethodType conType = CON_TYPES[nargs];
 MethodHandle gcon = spreadArguments(rawConstructor, conType, 1);
 if (gcon == null)  return null;
 mhs = new MethodHandle[] {
 FieldAccessor.ahandle(arrayClass, false),
 FieldAccessor.ahandle(arrayClass, true)
 };
 if (mhs[0].type().parameterType(0) == Class.class) {
-mhs[0] = MethodHandles.insertArguments(mhs[0], 0, elemClass);
+mhs[0] = mhs[0].bindTo(elemClass);
-mhs[1] = MethodHandles.insertArguments(mhs[1], 0, elemClass);
+mhs[1] = mhs[1].bindTo(elemClass);
 }
 synchronized (FieldAccessor.ARRAY_CACHE) {}  // memory barrier
 FieldAccessor.ARRAY_CACHE.put(elemClass, mhs);
 }
 return mhs[isSetter ? 1 : 0];
 throw uncaughtException(ex);
 }
 if (evclass != vclass || (!isStatic && ecclass != cclass)) {
 MethodType strongType = FieldAccessor.ftype(cclass, vclass, isSetter, isStatic);
 strongType = strongType.insertParameterTypes(0, FieldAccessor.class);
-mh = MethodHandles.convertArguments(mh, strongType);
+mh = convertArguments(mh, strongType, 0);
 }
 return mh;
 }
 /// Support for array element access
 } catch (ReflectiveOperationException ex) {
 throw uncaughtException(ex);
 }
 if (caclass != null) {
 MethodType strongType = FieldAccessor.atype(caclass, isSetter);
-mh = MethodHandles.insertArguments(mh, 0, caclass);
+mh = mh.bindTo(caclass);
-mh = MethodHandles.convertArguments(mh, strongType);
+mh = convertArguments(mh, strongType, 0);
 }
 return mh;
 }
 }
 DirectMethodHandle dmh = (DirectMethodHandle) info;
 if (receiver == null ||
 dmh.type().parameterType(0).isAssignableFrom(receiver.getClass())) {
 MethodHandle bmh = new BoundMethodHandle(dmh, receiver, 0);
 MethodType newType = target.type().dropParameterTypes(0, 1);
-return convertArguments(bmh, newType, bmh.type(), null);
+return convertArguments(bmh, newType, bmh.type(), 0);
 }
 }
 }
 if (target instanceof DirectMethodHandle)
 return new BoundMethodHandle((DirectMethodHandle)target, receiver, 0);
 static
 MethodHandle bindArgument(MethodHandle target, int argnum, Object receiver) {
 return new BoundMethodHandle(target, receiver, argnum);
 }
-static MethodHandle convertArguments(MethodHandle target,
+static MethodHandle permuteArguments(MethodHandle target,
 MethodType newType,
 MethodType oldType,
 int[] permutationOrNull) {
 assert(oldType.parameterCount() == target.type().parameterCount());
-if (permutationOrNull != null) {
+int outargs = oldType.parameterCount(), inargs = newType.parameterCount();
-int outargs = oldType.parameterCount(), inargs = newType.parameterCount();
+if (permutationOrNull.length != outargs)
-if (permutationOrNull.length != outargs)
+throw newIllegalArgumentException("wrong number of arguments in permutation");
-throw newIllegalArgumentException("wrong number of arguments in permutation");
+// Make the individual outgoing argument types match up first.
-// Make the individual outgoing argument types match up first.
+Class<?>[] callTypeArgs = new Class<?>[outargs];
-Class<?>[] callTypeArgs = new Class<?>[outargs];
+for (int i = 0; i < outargs; i++)
-for (int i = 0; i < outargs; i++)
+callTypeArgs[i] = newType.parameterType(permutationOrNull[i]);
-callTypeArgs[i] = newType.parameterType(permutationOrNull[i]);
+MethodType callType = MethodType.methodType(oldType.returnType(), callTypeArgs);
-MethodType callType = MethodType.methodType(oldType.returnType(), callTypeArgs);
+target = convertArguments(target, callType, oldType, 0);
-target = convertArguments(target, callType, oldType, null);
+assert(target != null);
-assert(target != null);
+oldType = target.type();
-oldType = target.type();
+List<Integer> goal = new ArrayList<Integer>();  // i*TOKEN
-List<Integer> goal = new ArrayList<Integer>();  // i*TOKEN
+List<Integer> state = new ArrayList<Integer>(); // i*TOKEN
-List<Integer> state = new ArrayList<Integer>(); // i*TOKEN
+List<Integer> drops = new ArrayList<Integer>(); // not tokens
-List<Integer> drops = new ArrayList<Integer>(); // not tokens
+List<Integer> dups = new ArrayList<Integer>();  // not tokens
-List<Integer> dups = new ArrayList<Integer>();  // not tokens
+final int TOKEN = 10; // to mark items which are symbolic only
-final int TOKEN = 10; // to mark items which are symbolic only
+// state represents the argument values coming into target
-// state represents the argument values coming into target
+for (int i = 0; i < outargs; i++) {
-for (int i = 0; i < outargs; i++) {
+state.add(permutationOrNull[i] * TOKEN);
-state.add(permutationOrNull[i] * TOKEN);
+}
-}
+// goal represents the desired state
-// goal represents the desired state
+for (int i = 0; i < inargs; i++) {
-for (int i = 0; i < inargs; i++) {
+if (state.contains(i * TOKEN)) {
-if (state.contains(i * TOKEN)) {
+goal.add(i * TOKEN);
-goal.add(i * TOKEN);
+} else {
+// adapter must initially drop all unused arguments
+drops.add(i);
+}
+}
+// detect duplications
+while (state.size() > goal.size()) {
+for (int i2 = 0; i2 < state.size(); i2++) {
+int arg1 = state.get(i2);
+int i1 = state.indexOf(arg1);
+if (i1 != i2) {
+// found duplicate occurrence at i2
+int arg2 = (inargs++) * TOKEN;
+state.set(i2, arg2);
+dups.add(goal.indexOf(arg1));
+goal.add(arg2);
+}
+}
+}
+assert(state.size() == goal.size());
+int size = goal.size();
+while (!state.equals(goal)) {
+// Look for a maximal sequence of adjacent misplaced arguments,
+// and try to rotate them into place.
+int bestRotArg = -10 * TOKEN, bestRotLen = 0;
+int thisRotArg = -10 * TOKEN, thisRotLen = 0;
+for (int i = 0; i < size; i++) {
+int arg = state.get(i);
+// Does this argument match the current run?
+if (arg == thisRotArg + TOKEN) {
+thisRotArg = arg;
+thisRotLen += 1;
+if (bestRotLen < thisRotLen) {
+bestRotLen = thisRotLen;
+bestRotArg = thisRotArg;
+}
 } else {
-// adapter must initially drop all unused arguments
+// The old sequence (if any) stops here.
-drops.add(i);
+thisRotLen = 0;
-}
+thisRotArg = -10 * TOKEN;
-}
+// But maybe a new one starts here also.
-// detect duplications
+int wantArg = goal.get(i);
-while (state.size() > goal.size()) {
+final int MAX_ARG_ROTATION = AdapterMethodHandle.MAX_ARG_ROTATION;
-for (int i2 = 0; i2 < state.size(); i2++) {
+if (arg != wantArg &&
-int arg1 = state.get(i2);
+arg >= wantArg - TOKEN * MAX_ARG_ROTATION &&
-int i1 = state.indexOf(arg1);
+arg <= wantArg + TOKEN * MAX_ARG_ROTATION) {
-if (i1 != i2) {
+thisRotArg = arg;
-// found duplicate occurrence at i2
+thisRotLen = 1;
-int arg2 = (inargs++) * TOKEN;
-state.set(i2, arg2);
-dups.add(goal.indexOf(arg1));
-goal.add(arg2);
 }
 }
 }
-assert(state.size() == goal.size());
+if (bestRotLen >= 2) {
-int size = goal.size();
+// Do a rotation if it can improve argument positioning
-while (!state.equals(goal)) {
+// by at least 2 arguments.  This is not always optimal,
-// Look for a maximal sequence of adjacent misplaced arguments,
+// but it seems to catch common cases.
-// and try to rotate them into place.
+int dstEnd = state.indexOf(bestRotArg);
-int bestRotArg = -10 * TOKEN, bestRotLen = 0;
+int srcEnd = goal.indexOf(bestRotArg);
-int thisRotArg = -10 * TOKEN, thisRotLen = 0;
+int rotBy = dstEnd - srcEnd;
-for (int i = 0; i < size; i++) {
+int dstBeg = dstEnd - (bestRotLen - 1);
-int arg = state.get(i);
+int srcBeg = srcEnd - (bestRotLen - 1);
-// Does this argument match the current run?
+assert((dstEnd | dstBeg | srcEnd | srcBeg) >= 0); // no negs
-if (arg == thisRotArg + TOKEN) {
+// Make a span which covers both source and destination.
-thisRotArg = arg;
+int rotBeg = Math.min(dstBeg, srcBeg);
-thisRotLen += 1;
+int rotEnd = Math.max(dstEnd, srcEnd);
-if (bestRotLen < thisRotLen) {
+int score = 0;
-bestRotLen = thisRotLen;
+for (int i = rotBeg; i <= rotEnd; i++) {
-bestRotArg = thisRotArg;
+if ((int)state.get(i) != (int)goal.get(i))
-}
+score += 1;
-} else {
+}
-// The old sequence (if any) stops here.
+List<Integer> rotSpan = state.subList(rotBeg, rotEnd+1);
-thisRotLen = 0;
+Collections.rotate(rotSpan, -rotBy);  // reverse direction
-thisRotArg = -10 * TOKEN;
+for (int i = rotBeg; i <= rotEnd; i++) {
-// But maybe a new one starts here also.
+if ((int)state.get(i) != (int)goal.get(i))
-int wantArg = goal.get(i);
+score -= 1;
-final int MAX_ARG_ROTATION = AdapterMethodHandle.MAX_ARG_ROTATION;
+}
-if (arg != wantArg &&
+if (score >= 2) {
-arg >= wantArg - TOKEN * MAX_ARG_ROTATION &&
+// Improved at least two argument positions.  Do it.
-arg <= wantArg + TOKEN * MAX_ARG_ROTATION) {
+List<Class<?>> ptypes = Arrays.asList(oldType.parameterArray());
-thisRotArg = arg;
+Collections.rotate(ptypes.subList(rotBeg, rotEnd+1), -rotBy);
-thisRotLen = 1;
+MethodType rotType = MethodType.methodType(oldType.returnType(), ptypes);
-}
+MethodHandle nextTarget
+= AdapterMethodHandle.makeRotateArguments(rotType, target,
+rotBeg, rotSpan.size(), rotBy);
+if (nextTarget != null) {
+//System.out.println("Rot: "+rotSpan+" by "+rotBy);
+target = nextTarget;
+oldType = rotType;
+continue;
 }
 }
-if (bestRotLen >= 2) {
+// Else de-rotate, and drop through to the swap-fest.
-// Do a rotation if it can improve argument positioning
+Collections.rotate(rotSpan, rotBy);
-// by at least 2 arguments.  This is not always optimal,
+}
-// but it seems to catch common cases.
-int dstEnd = state.indexOf(bestRotArg);
+// Now swap like the wind!
-int srcEnd = goal.indexOf(bestRotArg);
+List<Class<?>> ptypes = Arrays.asList(oldType.parameterArray());
-int rotBy = dstEnd - srcEnd;
+for (int i = 0; i < size; i++) {
-int dstBeg = dstEnd - (bestRotLen - 1);
+// What argument do I want here?
-int srcBeg = srcEnd - (bestRotLen - 1);
+int arg = goal.get(i);
-assert((dstEnd | dstBeg | srcEnd | srcBeg) >= 0); // no negs
+if (arg != state.get(i)) {
-// Make a span which covers both source and destination.
+// Where is it now?
-int rotBeg = Math.min(dstBeg, srcBeg);
+int j = state.indexOf(arg);
-int rotEnd = Math.max(dstEnd, srcEnd);
+Collections.swap(ptypes, i, j);
-int score = 0;
+MethodType swapType = MethodType.methodType(oldType.returnType(), ptypes);
-for (int i = rotBeg; i <= rotEnd; i++) {
+target = AdapterMethodHandle.makeSwapArguments(swapType, target, i, j);
-if ((int)state.get(i) != (int)goal.get(i))
+if (target == null)  throw newIllegalArgumentException("cannot swap");
-score += 1;
+assert(target.type() == swapType);
-}
+oldType = swapType;
-List<Integer> rotSpan = state.subList(rotBeg, rotEnd+1);
+Collections.swap(state, i, j);
-Collections.rotate(rotSpan, -rotBy);  // reverse direction
-for (int i = rotBeg; i <= rotEnd; i++) {
-if ((int)state.get(i) != (int)goal.get(i))
-score -= 1;
-}
-if (score >= 2) {
-// Improved at least two argument positions.  Do it.
-List<Class<?>> ptypes = Arrays.asList(oldType.parameterArray());
-Collections.rotate(ptypes.subList(rotBeg, rotEnd+1), -rotBy);
-MethodType rotType = MethodType.methodType(oldType.returnType(), ptypes);
-MethodHandle nextTarget
-= AdapterMethodHandle.makeRotateArguments(rotType, target,
-rotBeg, rotSpan.size(), rotBy);
-if (nextTarget != null) {
-//System.out.println("Rot: "+rotSpan+" by "+rotBy);
-target = nextTarget;
-oldType = rotType;
-continue;
-}
-}
-// Else de-rotate, and drop through to the swap-fest.
-Collections.rotate(rotSpan, rotBy);
 }
+}
-// Now swap like the wind!
+// One pass of swapping must finish the job.
-List<Class<?>> ptypes = Arrays.asList(oldType.parameterArray());
+assert(state.equals(goal));
-for (int i = 0; i < size; i++) {
+}
-// What argument do I want here?
+while (!dups.isEmpty()) {
-int arg = goal.get(i);
+// Grab a contiguous trailing sequence of dups.
-if (arg != state.get(i)) {
+int grab = dups.size() - 1;
-// Where is it now?
+int dupArgPos = dups.get(grab), dupArgCount = 1;
-int j = state.indexOf(arg);
+while (grab - 1 >= 0) {
-Collections.swap(ptypes, i, j);
+int dup0 = dups.get(grab - 1);
-MethodType swapType = MethodType.methodType(oldType.returnType(), ptypes);
+if (dup0 != dupArgPos - 1)  break;
-target = AdapterMethodHandle.makeSwapArguments(swapType, target, i, j);
+dupArgPos -= 1;
-if (target == null)  throw newIllegalArgumentException("cannot swap");
+dupArgCount += 1;
-assert(target.type() == swapType);
+grab -= 1;
-oldType = swapType;
+}
-Collections.swap(state, i, j);
+//if (dupArgCount > 1)  System.out.println("Dup: "+dups.subList(grab, dups.size()));
-}
+dups.subList(grab, dups.size()).clear();
-}
+// In the new target type drop that many args from the tail:
-// One pass of swapping must finish the job.
+List<Class<?>> ptypes = oldType.parameterList();
-assert(state.equals(goal));
+ptypes = ptypes.subList(0, ptypes.size() - dupArgCount);
-}
+MethodType dupType = MethodType.methodType(oldType.returnType(), ptypes);
-while (!dups.isEmpty()) {
+target = AdapterMethodHandle.makeDupArguments(dupType, target, dupArgPos, dupArgCount);
-// Grab a contiguous trailing sequence of dups.
+if (target == null)
-int grab = dups.size() - 1;
+throw newIllegalArgumentException("cannot dup");
-int dupArgPos = dups.get(grab), dupArgCount = 1;
+oldType = target.type();
-while (grab - 1 >= 0) {
+}
-int dup0 = dups.get(grab - 1);
+while (!drops.isEmpty()) {
-if (dup0 != dupArgPos - 1)  break;
+// Grab a contiguous initial sequence of drops.
-dupArgPos -= 1;
+int dropArgPos = drops.get(0), dropArgCount = 1;
-dupArgCount += 1;
+while (dropArgCount < drops.size()) {
-grab -= 1;
+int drop1 = drops.get(dropArgCount);
-}
+if (drop1 != dropArgPos + dropArgCount)  break;
-//if (dupArgCount > 1)  System.out.println("Dup: "+dups.subList(grab, dups.size()));
+dropArgCount += 1;
-dups.subList(grab, dups.size()).clear();
+}
-// In the new target type drop that many args from the tail:
+//if (dropArgCount > 1)  System.out.println("Drop: "+drops.subList(0, dropArgCount));
-List<Class<?>> ptypes = oldType.parameterList();
+drops.subList(0, dropArgCount).clear();
-ptypes = ptypes.subList(0, ptypes.size() - dupArgCount);
+List<Class<?>> dropTypes = newType.parameterList()
-MethodType dupType = MethodType.methodType(oldType.returnType(), ptypes);
+.subList(dropArgPos, dropArgPos + dropArgCount);
-target = AdapterMethodHandle.makeDupArguments(dupType, target, dupArgPos, dupArgCount);
+MethodType dropType = oldType.insertParameterTypes(dropArgPos, dropTypes);
-if (target == null)
+target = AdapterMethodHandle.makeDropArguments(dropType, target, dropArgPos, dropArgCount);
-throw newIllegalArgumentException("cannot dup");
+if (target == null)  throw newIllegalArgumentException("cannot drop");
 oldType = target.type();
 }
-while (!drops.isEmpty()) {
+return convertArguments(target, newType, oldType, 0);
-// Grab a contiguous initial sequence of drops.
+}
-int dropArgPos = drops.get(0), dropArgCount = 1;
-while (dropArgCount < drops.size()) {
+/*non-public*/ static
-int drop1 = drops.get(dropArgCount);
+MethodHandle convertArguments(MethodHandle target, MethodType newType, int level) {
-if (drop1 != dropArgPos + dropArgCount)  break;
+MethodType oldType = target.type();
-dropArgCount += 1;
+if (oldType.equals(newType))
-}
+return target;
-//if (dropArgCount > 1)  System.out.println("Drop: "+drops.subList(0, dropArgCount));
+assert(level > 1 || oldType.isConvertibleTo(newType));
-drops.subList(0, dropArgCount).clear();
+MethodHandle retFilter = null;
-List<Class<?>> dropTypes = newType.parameterList()
+Class<?> oldRT = oldType.returnType();
-.subList(dropArgPos, dropArgPos + dropArgCount);
+Class<?> newRT = newType.returnType();
-MethodType dropType = oldType.insertParameterTypes(dropArgPos, dropTypes);
+if (!VerifyType.isNullConversion(oldRT, newRT)) {
-target = AdapterMethodHandle.makeDropArguments(dropType, target, dropArgPos, dropArgCount);
+if (oldRT == void.class) {
-if (target == null)  throw newIllegalArgumentException("cannot drop");
+Wrapper wrap = newRT.isPrimitive() ? Wrapper.forPrimitiveType(newRT) : Wrapper.OBJECT;
-oldType = target.type();
+retFilter = ValueConversions.zeroConstantFunction(wrap);
-}
+} else {
-}
+retFilter = MethodHandles.identity(newRT);
+retFilter = convertArguments(retFilter, retFilter.type().changeParameterType(0, oldRT), level);
+}
+newType = newType.changeReturnType(oldRT);
+}
+MethodHandle res = null;
+Exception ex = null;
+try {
+res = convertArguments(target, newType, oldType, level);
+} catch (IllegalArgumentException ex1) {
+ex = ex1;
+}
+if (res == null) {
+WrongMethodTypeException wmt = new WrongMethodTypeException("cannot convert to "+newType+": "+target);
+wmt.initCause(ex);
+throw wmt;
+}
+if (retFilter != null)
+res = MethodHandles.filterReturnValue(res, retFilter);
+return res;
+}
+static MethodHandle convertArguments(MethodHandle target,
+MethodType newType,
+MethodType oldType,
+int level) {
+assert(oldType.parameterCount() == target.type().parameterCount());
 if (newType == oldType)
 return target;
 if (oldType.parameterCount() != newType.parameterCount())
-throw newIllegalArgumentException("mismatched parameter count");
+throw newIllegalArgumentException("mismatched parameter count", oldType, newType);
-MethodHandle res = AdapterMethodHandle.makePairwiseConvert(newType, target);
+MethodHandle res = AdapterMethodHandle.makePairwiseConvert(newType, target, level);
 if (res != null)
 return res;
+// We can come here in the case of target(int)void => (Object)void,
+// because the unboxing logic for Object => int is complex.
 int argc = oldType.parameterCount();
+assert(MethodHandleNatives.workaroundWithoutRicochetFrames());  // this code is deprecated
 // The JVM can't do it directly, so fill in the gap with a Java adapter.
 // TO DO: figure out what to put here from case-by-case experience
 // Use a heavier method:  Convert all the arguments to Object,
 // then back to the desired types.  We might have to use Java-based
 // method handles to do this.
 MethodType objType = MethodType.genericMethodType(argc);
-MethodHandle objTarget = AdapterMethodHandle.makePairwiseConvert(objType, target);
+MethodHandle objTarget = AdapterMethodHandle.makePairwiseConvert(objType, target, level);
 if (objTarget == null)
 objTarget = FromGeneric.make(target);
-res = AdapterMethodHandle.makePairwiseConvert(newType, objTarget);
+res = AdapterMethodHandle.makePairwiseConvert(newType, objTarget, level);
 if (res != null)
 return res;
 return ToGeneric.make(newType, objTarget);
 }
+static MethodHandle spreadArguments(MethodHandle target, Class<?> arrayType, int arrayLength) {
+MethodType oldType = target.type();
+int nargs = oldType.parameterCount();
+int keepPosArgs = nargs - arrayLength;
+MethodType newType = oldType
+.dropParameterTypes(keepPosArgs, nargs)
+.insertParameterTypes(keepPosArgs, arrayType);
+return spreadArguments(target, newType, keepPosArgs, arrayType, arrayLength);
+}
+static MethodHandle spreadArguments(MethodHandle target, MethodType newType, int spreadArgPos) {
+int arrayLength = target.type().parameterCount() - spreadArgPos;
+return spreadArguments(target, newType, spreadArgPos, Object[].class, arrayLength);
+}
 static MethodHandle spreadArguments(MethodHandle target,
 MethodType newType,
-int spreadArg) {
+int spreadArgPos,
+Class<?> arrayType,
+int arrayLength) {
 // TO DO: maybe allow the restarg to be Object and implicitly cast to Object[]
 MethodType oldType = target.type();
 // spread the last argument of newType to oldType
-int spreadCount = oldType.parameterCount() - spreadArg;
+assert(arrayLength == oldType.parameterCount() - spreadArgPos);
-Class<Object[]> spreadArgType = Object[].class;
+assert(newType.parameterType(spreadArgPos) == arrayType);
-MethodHandle res = AdapterMethodHandle.makeSpreadArguments(newType, target, spreadArgType, spreadArg, spreadCount);
+MethodHandle res = AdapterMethodHandle.makeSpreadArguments(newType, target, arrayType, spreadArgPos, arrayLength);
-if (res != null)
+if (res == null)  throw new IllegalArgumentException("spread on "+target+" with "+arrayType.getSimpleName());
-return res;
-// try an intermediate adapter
-Class<?> spreadType = null;
-if (spreadArg < 0 || spreadArg >= newType.parameterCount()
-|| !VerifyType.isSpreadArgType(spreadType = newType.parameterType(spreadArg)))
-throw newIllegalArgumentException("no restarg in "+newType);
-Class<?>[] ptypes = oldType.parameterArray();
-for (int i = 0; i < spreadCount; i++)
-ptypes[spreadArg + i] = VerifyType.spreadArgElementType(spreadType, i);
-MethodType midType = MethodType.methodType(newType.returnType(), ptypes);
-// after spreading, some arguments may need further conversion
-MethodHandle target2 = convertArguments(target, midType, oldType, null);
-if (target2 == null)
-throw new UnsupportedOperationException("NYI: convert "+midType+" =calls=> "+oldType);
-res = AdapterMethodHandle.makeSpreadArguments(newType, target2, spreadArgType, spreadArg, spreadCount);
-if (res != null)
-return res;
-res = SpreadGeneric.make(target2, spreadCount);
-if (res != null)
-res = convertArguments(res, newType, res.type(), null);
 return res;
 }
+static MethodHandle collectArguments(MethodHandle target,
+int collectArg,
+MethodHandle collector) {
+MethodType type = target.type();
+Class<?> collectType = collector.type().returnType();
+if (collectType != type.parameterType(collectArg))
+target = target.asType(type.changeParameterType(collectArg, collectType));
+MethodType newType = type
+.dropParameterTypes(collectArg, collectArg+1)
+.insertParameterTypes(collectArg, collector.type().parameterArray());
+return collectArguments(target, newType, collectArg, collector);
+}
 static MethodHandle collectArguments(MethodHandle target,
 MethodType newType,
 int collectArg,
 MethodHandle collector) {
 MethodType oldType = target.type();     // (a...,c)=>r
-if (collector == null) {
-int numCollect = newType.parameterCount() - oldType.parameterCount() + 1;
-collector = ValueConversions.varargsArray(numCollect);
-}
 //         newType                      // (a..., b...)=>r
 MethodType colType = collector.type();  // (b...)=>c
 //         oldType                      // (a..., b...)=>r
 assert(newType.parameterCount() == collectArg + colType.parameterCount());
 assert(oldType.parameterCount() == collectArg + 1);
-MethodHandle gtarget = convertArguments(target, oldType.generic(), oldType, null);
+MethodHandle result = null;
-MethodHandle gcollector = convertArguments(collector, colType.generic(), colType, null);
+if (AdapterMethodHandle.canCollectArguments(oldType, colType, collectArg, false)) {
-if (gtarget == null || gcollector == null)  return null;
+result = AdapterMethodHandle.makeCollectArguments(target, collector, collectArg, false);
-MethodHandle gresult = FilterGeneric.makeArgumentCollector(gcollector, gtarget);
+}
-MethodHandle result = convertArguments(gresult, newType, gresult.type(), null);
+if (result == null) {
+assert(MethodHandleNatives.workaroundWithoutRicochetFrames());  // this code is deprecated
+MethodHandle gtarget = convertArguments(target, oldType.generic(), oldType, 0);
+MethodHandle gcollector = convertArguments(collector, colType.generic(), colType, 0);
+if (gtarget == null || gcollector == null)  return null;
+MethodHandle gresult = FilterGeneric.makeArgumentCollector(gcollector, gtarget);
+result = convertArguments(gresult, newType, gresult.type(), 0);
+}
 return result;
 }
 static MethodHandle filterArgument(MethodHandle target,
 int pos,
 MethodHandle filter) {
-MethodType ttype = target.type(), gttype = ttype.generic();
+MethodType ttype = target.type();
+MethodType ftype = filter.type();
+assert(ftype.parameterCount() == 1);
+MethodType rtype = ttype.changeParameterType(pos, ftype.parameterType(0));
+MethodType gttype = ttype.generic();
 if (ttype != gttype) {
-target = convertArguments(target, gttype, ttype, null);
+target = convertArguments(target, gttype, ttype, 0);
 ttype = gttype;
 }
-MethodType ftype = filter.type(), gftype = ftype.generic();
+MethodType gftype = ftype.generic();
-if (ftype.parameterCount() != 1)
-throw new InternalError();
 if (ftype != gftype) {
-filter = convertArguments(filter, gftype, ftype, null);
+filter = convertArguments(filter, gftype, ftype, 0);
 ftype = gftype;
 }
-if (ftype == ttype) {
+MethodHandle result = null;
+if (AdapterMethodHandle.canCollectArguments(ttype, ftype, pos, false)) {
+result = AdapterMethodHandle.makeCollectArguments(target, filter, pos, false);
+}
+if (result == null) {
+assert(MethodHandleNatives.workaroundWithoutRicochetFrames());  // this code is deprecated
+if (ftype == ttype) {
 // simple unary case
-return FilterOneArgument.make(filter, target);
+result = FilterOneArgument.make(filter, target);
-}
+} else {
-return FilterGeneric.makeArgumentFilter(pos, filter, target);
+result = FilterGeneric.makeArgumentFilter(pos, filter, target);
+}
+}
+if (result.type() != rtype)
+result = result.asType(rtype);
+return result;
 }
 static MethodHandle foldArguments(MethodHandle target,
 MethodType newType,
-MethodHandle combiner) {
+int foldPos,
+MethodHandle combiner) {
 MethodType oldType = target.type();
 MethodType ctype = combiner.type();
-MethodHandle gtarget = convertArguments(target, oldType.generic(), oldType, null);
+if (AdapterMethodHandle.canCollectArguments(oldType, ctype, foldPos, true)) {
-MethodHandle gcombiner = convertArguments(combiner, ctype.generic(), ctype, null);
+MethodHandle res = AdapterMethodHandle.makeCollectArguments(target, combiner, foldPos, true);
+if (res != null)  return res;
+}
+assert(MethodHandleNatives.workaroundWithoutRicochetFrames());  // this code is deprecated
+if (foldPos != 0)  return null;
+MethodHandle gtarget = convertArguments(target, oldType.generic(), oldType, 0);
+MethodHandle gcombiner = convertArguments(combiner, ctype.generic(), ctype, 0);
+if (ctype.returnType() == void.class) {
+gtarget = dropArguments(gtarget, oldType.generic().insertParameterTypes(foldPos, Object.class), foldPos);
+}
 if (gtarget == null || gcombiner == null)  return null;
 MethodHandle gresult = FilterGeneric.makeArgumentFolder(gcombiner, gtarget);
-MethodHandle result = convertArguments(gresult, newType, gresult.type(), null);
+return convertArguments(gresult, newType, gresult.type(), 0);
-return result;
 }
 static
 MethodHandle dropArguments(MethodHandle target,
 MethodType newType, int argnum) {
 super(invoker);
 this.test = test;
 this.target = target;
 this.fallback = fallback;
 }
+// FIXME: Build the control flow out of foldArguments.
 static MethodHandle make(MethodHandle test, MethodHandle target, MethodHandle fallback) {
 MethodType type = target.type();
 int nargs = type.parameterCount();
 if (nargs < INVOKES.length) {
 MethodHandle invoke = INVOKES[nargs];
 MethodType gtype = type.generic();
 assert(invoke.type().dropParameterTypes(0,1) == gtype);
-MethodHandle gtest = convertArguments(test, gtype.changeReturnType(boolean.class), test.type(), null);
+MethodHandle gtest = convertArguments(test, gtype.changeReturnType(boolean.class), test.type(), 0);
-MethodHandle gtarget = convertArguments(target, gtype, type, null);
+MethodHandle gtarget = convertArguments(target, gtype, type, 0);
-MethodHandle gfallback = convertArguments(fallback, gtype, type, null);
+MethodHandle gfallback = convertArguments(fallback, gtype, type, 0);
 if (gtest == null || gtarget == null || gfallback == null)  return null;
 MethodHandle gguard = new GuardWithTest(invoke, gtest, gtarget, gfallback);
-return convertArguments(gguard, type, gtype, null);
+return convertArguments(gguard, type, gtype, 0);
 } else {
 MethodHandle invoke = VARARGS_INVOKE;
 MethodType gtype = MethodType.genericMethodType(1);
 assert(invoke.type().dropParameterTypes(0,1) == gtype);
 MethodHandle gtest = spreadArguments(test, gtype.changeReturnType(boolean.class), 0);
 private final Class<? extends Throwable> exType;
 private final MethodHandle catcher;
 GuardWithCatch(MethodHandle target, Class<? extends Throwable> exType, MethodHandle catcher) {
 this(INVOKES[target.type().parameterCount()], target, exType, catcher);
 }
-GuardWithCatch(MethodHandle invoker,
+// FIXME: Build the control flow out of foldArguments.
-MethodHandle target, Class<? extends Throwable> exType, MethodHandle catcher) {
+GuardWithCatch(MethodHandle invoker,
+MethodHandle target, Class<? extends Throwable> exType, MethodHandle catcher) {
 super(invoker);
 this.target = target;
 this.exType = exType;
 this.catcher = catcher;
 }
 MethodType ctype = catcher.type();
 int nargs = type.parameterCount();
 if (nargs < GuardWithCatch.INVOKES.length) {
 MethodType gtype = type.generic();
 MethodType gcatchType = gtype.insertParameterTypes(0, Throwable.class);
-MethodHandle gtarget = convertArguments(target, gtype, type, null);
+MethodHandle gtarget = convertArguments(target, gtype, type, 0);
-MethodHandle gcatcher = convertArguments(catcher, gcatchType, ctype, null);
+MethodHandle gcatcher = convertArguments(catcher, gcatchType, ctype, 0);
 MethodHandle gguard = new GuardWithCatch(gtarget, exType, gcatcher);
 if (gtarget == null || gcatcher == null || gguard == null)  return null;
-return convertArguments(gguard, type, gtype, null);
+return convertArguments(gguard, type, gtype, 0);
 } else {
 MethodType gtype = MethodType.genericMethodType(0, true);
 MethodType gcatchType = gtype.insertParameterTypes(0, Throwable.class);
 MethodHandle gtarget = spreadArguments(target, gtype, 0);
 MethodHandle gcatcher = spreadArguments(catcher, gcatchType, 1);

changeset 9646	5ebbe5ab084f
parent 8822	8145ab9f5f86
child 9730	e4b334d47f4b