private boolean returnConversionNeeded(MethodType callerType, MethodHandle target) {
Class<?> needType = callerType.returnType();
if (needType == erasedCallerType.returnType())
return false; // no conversions possible, since must be primitive or Object
Class<?> haveType = target.type().returnType();
if (VerifyType.isNullConversion(haveType, needType) && !needType.isInterface()) return false;
return true;
}
private MethodHandle addReturnConversion(MethodHandle finisher, Class<?> type) {
// FIXME: This is slow because it creates a closure node on every call that requires a return
// cast.
MethodType finisherType = finisher.type();
MethodHandle caster = ValueConversions.identity(type);
caster = caster.asType(caster.type().changeParameterType(0, finisherType.returnType()));
finisher = MethodHandles.filterReturnValue(finisher, caster);
return finisher.asType(finisherType);
}
private boolean returnConversionPossible() {
Class<?> needType = erasedCallerType.returnType();
return !needType.isPrimitive();
}
private MethodHandle dispatchWithConversion(MethodType callerType, MethodHandle target) {
MethodHandle finisher = dispatch(callerType, target);
if (returnConversionNeeded(callerType, target))
finisher = addReturnConversion(finisher, callerType.returnType()); // FIXME: slow
return finisher;
}
