jdk8-mips64-public/nashorn: comparison src/jdk/internal/dynalink/support/TypeConverterFactory.java

-:981feb6ad9cc
+:99571b7922c0
 import jdk.internal.dynalink.linker.ConversionComparator.Comparison;
 import jdk.internal.dynalink.linker.GuardedInvocation;
 import jdk.internal.dynalink.linker.GuardedTypeConversion;
 import jdk.internal.dynalink.linker.GuardingTypeConverterFactory;
 import jdk.internal.dynalink.linker.LinkerServices;
+import jdk.internal.dynalink.linker.MethodTypeConversionStrategy;
 /**
 * A factory for type converters. This class is the main implementation behind the
 * {@link LinkerServices#asType(MethodHandle, MethodType)}. It manages the known {@link GuardingTypeConverterFactory}
 * instances and creates appropriate converters for method handles.
 */
 public class TypeConverterFactory {
 private final GuardingTypeConverterFactory[] factories;
 private final ConversionComparator[] comparators;
+private final MethodTypeConversionStrategy autoConversionStrategy;
 private final ClassValue<ClassMap<MethodHandle>> converterMap = new ClassValue<ClassMap<MethodHandle>>() {
 @Override
 protected ClassMap<MethodHandle> computeValue(final Class<?> sourceType) {
 return new ClassMap<MethodHandle>(getClassLoader(sourceType)) {
 /**
 * Creates a new type converter factory from the available {@link GuardingTypeConverterFactory} instances.
 *
 * @param factories the {@link GuardingTypeConverterFactory} instances to compose.
-*/
+* @param autoConversionStrategy conversion strategy for automatic type conversions. After
-public TypeConverterFactory(final Iterable<? extends GuardingTypeConverterFactory> factories) {
+* {@link #asType(java.lang.invoke.MethodHandle, java.lang.invoke.MethodType)} has applied all custom
+* conversions to a method handle, it still needs to effect
+* {@link TypeUtilities#isMethodInvocationConvertible(Class, Class) method invocation conversions} that
+* can usually be automatically applied as per
+* {@link java.lang.invoke.MethodHandle#asType(java.lang.invoke.MethodType)}.
+* However, sometimes language runtimes will want to customize even those conversions for their own call
+* sites. A typical example is allowing unboxing of null return values, which is by default prohibited by
+* ordinary {@code MethodHandles.asType}. In this case, a language runtime can install its own custom
+* automatic conversion strategy, that can deal with null values. Note that when the strategy's
+* {@link MethodTypeConversionStrategy#asType(java.lang.invoke.MethodHandle, java.lang.invoke.MethodType)}
+* is invoked, the custom language conversions will already have been applied to the method handle, so by
+* design the difference between the handle's current method type and the desired final type will always
+* only be ones that can be subjected to method invocation conversions. Can be null, in which case no
+* custom strategy is employed.
+*/
+public TypeConverterFactory(final Iterable<? extends GuardingTypeConverterFactory> factories,
+final MethodTypeConversionStrategy autoConversionStrategy) {
 final List<GuardingTypeConverterFactory> l = new LinkedList<>();
 final List<ConversionComparator> c = new LinkedList<>();
 for(final GuardingTypeConverterFactory factory: factories) {
 l.add(factory);
 if(factory instanceof ConversionComparator) {
 c.add((ConversionComparator)factory);
 }
 }
 this.factories = l.toArray(new GuardingTypeConverterFactory[l.size()]);
 this.comparators = c.toArray(new ConversionComparator[c.size()]);
+this.autoConversionStrategy = autoConversionStrategy;
 }
 /**
 * Similar to {@link MethodHandle#asType(MethodType)} except it also hooks in method handles produced by
 * {@link GuardingTypeConverterFactory} implementations, providing for language-specific type coercing of
-* parameters. It will apply {@link MethodHandle#asType(MethodType)} for all primitive-to-primitive,
+* parameters. For all conversions that are not a JLS method invocation conversion it'll insert
-* wrapper-to-primitive, primitive-to-wrapper conversions as well as for all upcasts. For all other conversions,
+* {@link MethodHandles#filterArguments(MethodHandle, int, MethodHandle...)} with composite filters
-* it'll insert {@link MethodHandles#filterArguments(MethodHandle, int, MethodHandle...)} with composite filters
+* provided by {@link GuardingTypeConverterFactory} implementations. For the remaining JLS method invocation
-* provided by {@link GuardingTypeConverterFactory} implementations.
+* conversions, it will invoke {@link MethodTypeConversionStrategy#asType(MethodHandle, MethodType)} first
+* if an automatic conversion strategy was specified in the
+* {@link #TypeConverterFactory(Iterable, MethodTypeConversionStrategy) constructor}, and finally apply
+* {@link MethodHandle#asType(MethodType)} for any remaining conversions.
 *
 * @param handle target method handle
 * @param fromType the types of source arguments
-* @return a method handle that is a suitable combination of {@link MethodHandle#asType(MethodType)} and
+* @return a method handle that is a suitable combination of {@link MethodHandle#asType(MethodType)},
+* {@link MethodTypeConversionStrategy#asType(MethodHandle, MethodType)}, and
 * {@link MethodHandles#filterArguments(MethodHandle, int, MethodHandle...)} with
 * {@link GuardingTypeConverterFactory} produced type converters as filters.
 */
 public MethodHandle asType(final MethodHandle handle, final MethodType fromType) {
 MethodHandle newHandle = handle;
 newHandle = MethodHandles.filterReturnValue(newHandle, converter);
 }
 }
 }
-// Take care of automatic conversions
+// Give change to automatic conversion strategy, if one is present.
-return newHandle.asType(fromType);
+final MethodHandle autoConvertedHandle =
+autoConversionStrategy != null ? autoConversionStrategy.asType(newHandle, fromType) : newHandle;
+// Do a final asType for any conversions that remain.
+return autoConvertedHandle.asType(fromType);
 }
 private static MethodHandle applyConverters(final MethodHandle handle, final int pos, final List<MethodHandle> converters) {
 if(converters.isEmpty()) {
 return handle;

Mercurial > jdk8-mips64-public > nashorn / file comparison

comparison: src/jdk/internal/dynalink/support/TypeConverterFactory.java

src/jdk/internal/dynalink/support/TypeConverterFactory.java