jdk-sandbox: comparison nashorn/src/jdk/internal/dynalink/beans/OverloadedDynamicMethod.java

equal deleted inserted replaced

-:3e7bff1b7b59
+:9bbc4b8832b2
 */
 package jdk.internal.dynalink.beans;
 import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
 import java.lang.invoke.MethodType;
+import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.LinkedList;
 import java.util.List;
+import jdk.internal.dynalink.CallSiteDescriptor;
 import jdk.internal.dynalink.beans.ApplicableOverloadedMethods.ApplicabilityTest;
 import jdk.internal.dynalink.linker.LinkerServices;
 import jdk.internal.dynalink.support.TypeUtilities;
 /**
-* Represents an overloaded method.
+* Represents a group of {@link SingleDynamicMethod} objects that represents all overloads of a particular name (or all
+* constructors) for a particular class. Correctly handles overload resolution, variable arity methods, and caller
+* sensitive methods within the overloads.
 *
 * @author Attila Szegedi
 */
 class OverloadedDynamicMethod extends DynamicMethod {
 /**
 * Holds a list of all methods.
 */
-private final LinkedList<MethodHandle> methods;
+private final LinkedList<SingleDynamicMethod> methods;
 private final ClassLoader classLoader;
 /**
 * Creates a new overloaded dynamic method.
 *
 * @param clazz the class this method belongs to
 * @param name the name of the method
 */
 OverloadedDynamicMethod(Class<?> clazz, String name) {
-this(new LinkedList<MethodHandle>(), clazz.getClassLoader(), getClassAndMethodName(clazz, name));
+this(new LinkedList<SingleDynamicMethod>(), clazz.getClassLoader(), getClassAndMethodName(clazz, name));
 }
-private OverloadedDynamicMethod(LinkedList<MethodHandle> methods, ClassLoader classLoader, String name) {
+private OverloadedDynamicMethod(LinkedList<SingleDynamicMethod> methods, ClassLoader classLoader, String name) {
 super(name);
 this.methods = methods;
 this.classLoader = classLoader;
 }
 @Override
-SimpleDynamicMethod getMethodForExactParamTypes(String paramTypes) {
+SingleDynamicMethod getMethodForExactParamTypes(String paramTypes) {
-final LinkedList<MethodHandle> matchingMethods = new LinkedList<>();
+final LinkedList<SingleDynamicMethod> matchingMethods = new LinkedList<>();
-for(MethodHandle method: methods) {
+for(SingleDynamicMethod method: methods) {
-if(typeMatchesDescription(paramTypes, method.type())) {
+final SingleDynamicMethod matchingMethod = method.getMethodForExactParamTypes(paramTypes);
-matchingMethods.add(method);
+if(matchingMethod != null) {
+matchingMethods.add(matchingMethod);
 }
 }
 switch(matchingMethods.size()) {
 case 0: {
 return null;
 }
 case 1: {
-final MethodHandle target = matchingMethods.get(0);
+return matchingMethods.getFirst();
-return new SimpleDynamicMethod(target, SimpleDynamicMethod.getMethodNameWithSignature(target, getName()));
 }
 default: {
 throw new BootstrapMethodError("Can't choose among " + matchingMethods + " for argument types "
 + paramTypes + " for method " + getName());
 }
 }
 }
 @Override
-public MethodHandle getInvocation(final MethodType callSiteType, final LinkerServices linkerServices) {
+public MethodHandle getInvocation(final CallSiteDescriptor callSiteDescriptor, final LinkerServices linkerServices) {
+final MethodType callSiteType = callSiteDescriptor.getMethodType();
 // First, find all methods applicable to the call site by subtyping (JLS 15.12.2.2)
 final ApplicableOverloadedMethods subtypingApplicables = getApplicables(callSiteType,
 ApplicableOverloadedMethods.APPLICABLE_BY_SUBTYPING);
 // Next, find all methods applicable by method invocation conversion to the call site (JLS 15.12.2.3).
 final ApplicableOverloadedMethods methodInvocationApplicables = getApplicables(callSiteType,
 // Finally, find all methods applicable by variable arity invocation. (JLS 15.12.2.4).
 final ApplicableOverloadedMethods variableArityApplicables = getApplicables(callSiteType,
 ApplicableOverloadedMethods.APPLICABLE_BY_VARIABLE_ARITY);
 // Find the methods that are maximally specific based on the call site signature
-List<MethodHandle> maximallySpecifics = subtypingApplicables.findMaximallySpecificMethods();
+List<SingleDynamicMethod> maximallySpecifics = subtypingApplicables.findMaximallySpecificMethods();
 if(maximallySpecifics.isEmpty()) {
 maximallySpecifics = methodInvocationApplicables.findMaximallySpecificMethods();
 if(maximallySpecifics.isEmpty()) {
 maximallySpecifics = variableArityApplicables.findMaximallySpecificMethods();
 }
 // might match more concrete types passed in invocations. That's why we provisionally call them "invokables".
 // This is typical for very generic signatures at call sites. Typical example: call site specifies
 // (Object, Object), and we have a method whose parameter types are (String, int). None of the JLS applicability
 // rules will trigger, but we must consider the method, as it can be the right match for a concrete invocation.
 @SuppressWarnings({ "unchecked", "rawtypes" })
-final List<MethodHandle> invokables = (List)methods.clone();
+final List<SingleDynamicMethod> invokables = (List)methods.clone();
 invokables.removeAll(subtypingApplicables.getMethods());
 invokables.removeAll(methodInvocationApplicables.getMethods());
 invokables.removeAll(variableArityApplicables.getMethods());
-for(final Iterator<MethodHandle> it = invokables.iterator(); it.hasNext();) {
+for(final Iterator<SingleDynamicMethod> it = invokables.iterator(); it.hasNext();) {
-final MethodHandle m = it.next();
+final SingleDynamicMethod m = it.next();
 if(!isApplicableDynamically(linkerServices, callSiteType, m)) {
 it.remove();
 }
 }
 // No overloads can ever match the call site type
 return null;
 }
 case 1: {
 // Very lucky, we ended up with a single candidate method handle based on the call site signature; we
-// can link it very simply by delegating to a SimpleDynamicMethod.
+// can link it very simply by delegating to the SingleDynamicMethod.
-final MethodHandle mh = invokables.iterator().next();
+invokables.iterator().next().getInvocation(callSiteDescriptor, linkerServices);
-return new SimpleDynamicMethod(mh).getInvocation(callSiteType, linkerServices);
 }
 default: {
 // We have more than one candidate. We have no choice but to link to a method that resolves overloads on
 // every invocation (alternatively, we could opportunistically link the one method that resolves for the
 // current arguments, but we'd need to install a fairly complex guard for that and when it'd fail, we'd
-// go back all the way to candidate selection.
+// go back all the way to candidate selection. Note that we're resolving any potential caller sensitive
-// TODO: cache per call site type
+// methods here to their handles, as the OverloadedMethod instance is specific to a call site, so it
-return new OverloadedMethod(invokables, this, callSiteType, linkerServices).getInvoker();
+// has an already determined Lookup.
+final List<MethodHandle> methodHandles = new ArrayList<>(invokables.size());
+final MethodHandles.Lookup lookup = callSiteDescriptor.getLookup();
+for(SingleDynamicMethod method: invokables) {
+methodHandles.add(method.getTarget(lookup));
+}
+return new OverloadedMethod(methodHandles, this, callSiteType, linkerServices).getInvoker();
 }
 }
 }
 @Override
-public boolean contains(MethodHandle mh) {
+public boolean contains(SingleDynamicMethod m) {
-final MethodType type = mh.type();
+for(SingleDynamicMethod method: methods) {
-for(MethodHandle method: methods) {
+if(method.contains(m)) {
-if(typesEqualNoReceiver(type, method.type())) {
 return true;
 }
 }
 return false;
-}
-private static boolean typesEqualNoReceiver(MethodType type1, MethodType type2) {
-final int pc = type1.parameterCount();
-if(pc != type2.parameterCount()) {
-return false;
-}
-for(int i = 1; i < pc; ++i) { // i = 1: ignore receiver
-if(type1.parameterType(i) != type2.parameterType(i)) {
-return false;
-}
-}
-return true;
 }
 ClassLoader getClassLoader() {
 return classLoader;
 }
 private static boolean isApplicableDynamically(LinkerServices linkerServices, MethodType callSiteType,
-MethodHandle m) {
+SingleDynamicMethod m) {
-final MethodType methodType = m.type();
+final MethodType methodType = m.getMethodType();
-final boolean varArgs = m.isVarargsCollector();
+final boolean varArgs = m.isVarArgs();
 final int fixedArgLen = methodType.parameterCount() - (varArgs ? 1 : 0);
 final int callSiteArgLen = callSiteType.parameterCount();
 // Arity checks
 if(varArgs) {
 private ApplicableOverloadedMethods getApplicables(MethodType callSiteType, ApplicabilityTest test) {
 return new ApplicableOverloadedMethods(methods, callSiteType, test);
 }
 /**
-* Add a method identified by a {@link SimpleDynamicMethod} to this overloaded method's set.
-*
-* @param method the method to add.
-*/
-void addMethod(SimpleDynamicMethod method) {
-addMethod(method.getTarget());
-}
-/**
 * Add a method to this overloaded method's set.
 *
 * @param method a method to add
 */
-public void addMethod(MethodHandle method) {
+public void addMethod(SingleDynamicMethod method) {
 methods.add(method);
 }
 }

changeset 18841	9bbc4b8832b2
parent 16245	6a1c6c8bc113
child 19630	99f53f31008e