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

-:981feb6ad9cc
+:99571b7922c0
 import java.util.Set;
 import jdk.internal.dynalink.beans.BeansLinker;
 import jdk.internal.dynalink.linker.GuardingDynamicLinker;
 import jdk.internal.dynalink.linker.GuardingTypeConverterFactory;
 import jdk.internal.dynalink.linker.LinkRequest;
+import jdk.internal.dynalink.linker.MethodTypeConversionStrategy;
 import jdk.internal.dynalink.support.AutoDiscovery;
 import jdk.internal.dynalink.support.BottomGuardingDynamicLinker;
 import jdk.internal.dynalink.support.ClassLoaderGetterContextProvider;
 import jdk.internal.dynalink.support.CompositeGuardingDynamicLinker;
 import jdk.internal.dynalink.support.CompositeTypeBasedGuardingDynamicLinker;
 import jdk.internal.dynalink.support.DefaultPrelinkFilter;
 import jdk.internal.dynalink.support.LinkerServicesImpl;
 import jdk.internal.dynalink.support.TypeConverterFactory;
+import jdk.internal.dynalink.support.TypeUtilities;
 /**
 * A factory class for creating {@link DynamicLinker}s. The most usual dynamic linker is a linker that is a composition
 * of all {@link GuardingDynamicLinker}s known and pre-created by the caller as well as any
 * {@link AutoDiscovery automatically discovered} guarding linkers and the standard fallback {@link BeansLinker} and a
 * {@link DefaultPrelinkFilter}. See {@link DynamicLinker} documentation for tips on how to use this class.
 *
 * @author Attila Szegedi
 */
 public class DynamicLinkerFactory {
 /**
 * Default value for {@link #setUnstableRelinkThreshold(int) unstable relink threshold}.
 */
 public static final int DEFAULT_UNSTABLE_RELINK_THRESHOLD = 8;
 private List<? extends GuardingDynamicLinker> fallbackLinkers;
 private int runtimeContextArgCount = 0;
 private boolean syncOnRelink = false;
 private int unstableRelinkThreshold = DEFAULT_UNSTABLE_RELINK_THRESHOLD;
 private GuardedInvocationFilter prelinkFilter;
+private MethodTypeConversionStrategy autoConversionStrategy;
 /**
 * Sets the class loader for automatic discovery of available linkers. If not set explicitly, then the thread
 * context class loader at the time of {@link #createLinker()} invocation will be used.
 *
 * When not set explicitly, {@link DefaultPrelinkFilter} will be used.
 * @param prelinkFilter the pre-link filter for the dynamic linker.
 */
 public void setPrelinkFilter(final GuardedInvocationFilter prelinkFilter) {
 this.prelinkFilter = prelinkFilter;
+}
+/**
+* Sets an object representing the conversion strategy for automatic type conversions. After
+* {@link TypeConverterFactory#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. The strategy also doesn't need to
+* invoke a final {@code MethodHandle.asType()} as the converter factory will do that as the final step.
+* @param autoConversionStrategy the strategy for applying method invocation conversions for the linker
+* created by this factory.
+*/
+public void setAutoConversionStrategy(final MethodTypeConversionStrategy autoConversionStrategy) {
+this.autoConversionStrategy = autoConversionStrategy;
 }
 /**
 * Creates a new dynamic linker consisting of all the prioritized, autodiscovered, and fallback linkers as well as
 * the pre-link filter.
 if(prelinkFilter == null) {
 prelinkFilter = new DefaultPrelinkFilter();
 }
-return new DynamicLinker(new LinkerServicesImpl(new TypeConverterFactory(typeConverters), composite),
+return new DynamicLinker(new LinkerServicesImpl(new TypeConverterFactory(typeConverters,
-prelinkFilter, runtimeContextArgCount, syncOnRelink, unstableRelinkThreshold);
+autoConversionStrategy), composite), prelinkFilter, runtimeContextArgCount, syncOnRelink,
+unstableRelinkThreshold);
 }
 private static ClassLoader getThreadContextClassLoader() {
 return AccessController.doPrivileged(new PrivilegedAction<ClassLoader>() {
 @Override

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

comparison: src/jdk/internal/dynalink/DynamicLinkerFactory.java

src/jdk/internal/dynalink/DynamicLinkerFactory.java