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

-:3245e174fe3a
+:f8221ce53c2e
 import java.util.LinkedList;
 import java.util.List;
 import jdk.internal.dynalink.beans.ApplicableOverloadedMethods.ApplicabilityTest;
 import jdk.internal.dynalink.linker.LinkerServices;
 import jdk.internal.dynalink.support.TypeUtilities;
 /**
 * Represents an overloaded method.
 *
 * @author Attila Szegedi
 // 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.
 final MethodHandle mh = invokables.iterator().next();
 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
-// We have more than one candidate. We have no choice but to link to a method that resolves overloads on every
+// every invocation (alternatively, we could opportunistically link the one method that resolves for the
-// invocation (alternatively, we could opportunistically link the one method that resolves for the current
+// current arguments, but we'd need to install a fairly complex guard for that and when it'd fail, we'd
-// arguments, but we'd need to install a fairly complex guard for that and when it'd fail, we'd go back all the
+// go back all the way to candidate selection.
-// way to candidate selection.
+// TODO: cache per call site type
-// TODO: cache per call site type
+return new OverloadedMethod(invokables, this, callSiteType, linkerServices).getInvoker();
-return new OverloadedMethod(invokables, this, callSiteType, linkerServices).getInvoker();
+}
+}
 }
 @Override
 public boolean contains(MethodHandle mh) {
 final MethodType type = mh.type();
 MethodHandle m) {
 final MethodType methodType = m.type();
 final boolean varArgs = m.isVarargsCollector();
 final int fixedArgLen = methodType.parameterCount() - (varArgs ? 1 : 0);
 final int callSiteArgLen = callSiteType.parameterCount();
+// Arity checks
 if(varArgs) {
 if(callSiteArgLen < fixedArgLen) {
 return false;
 }
 } else if(callSiteArgLen != fixedArgLen) {
 return false;
 }
-// Starting from 1, as receiver type doesn't participate
+// Fixed arguments type checks, starting from 1, as receiver type doesn't participate
 for(int i = 1; i < fixedArgLen; ++i) {
 if(!isApplicableDynamically(linkerServices, callSiteType.parameterType(i), methodType.parameterType(i))) {
 return false;
 }
 }
-if(varArgs) {
+if(!varArgs) {
-final Class<?> varArgArrayType = methodType.parameterType(fixedArgLen);
+// Not vararg; both arity and types matched.
-final Class<?> varArgType = varArgArrayType.getComponentType();
-if(fixedArgLen == callSiteArgLen - 1) {
-final Class<?> callSiteArgType = callSiteType.parameterType(fixedArgLen);
-// Exactly one vararg; check both exact matching and component
-// matching.
-return isApplicableDynamically(linkerServices, callSiteArgType, varArgArrayType)
-|| isApplicableDynamically(linkerServices, callSiteArgType, varArgType);
-} else {
-for(int i = fixedArgLen; i < callSiteArgLen; ++i) {
-if(!isApplicableDynamically(linkerServices, callSiteType.parameterType(i), varArgType)) {
-return false;
-}
-}
-return true;
-}
-} else {
 return true;
 }
+final Class<?> varArgArrayType = methodType.parameterType(fixedArgLen);
+final Class<?> varArgType = varArgArrayType.getComponentType();
+if(fixedArgLen == callSiteArgLen - 1) {
+// Exactly one vararg; check both array type matching and array component type matching.
+final Class<?> callSiteArgType = callSiteType.parameterType(fixedArgLen);
+return isApplicableDynamically(linkerServices, callSiteArgType, varArgArrayType)
+|| isApplicableDynamically(linkerServices, callSiteArgType, varArgType);
+}
+// Either zero, or more than one vararg; check if all actual vararg types match the vararg array component type.
+for(int i = fixedArgLen; i < callSiteArgLen; ++i) {
+if(!isApplicableDynamically(linkerServices, callSiteType.parameterType(i), varArgType)) {
+return false;
+}
+}
+return true;
 }
 private static boolean isApplicableDynamically(LinkerServices linkerServices, Class<?> callSiteType,
 Class<?> methodType) {
 return TypeUtilities.isPotentiallyConvertible(callSiteType, methodType)
 /**
 * Add a method identified by a {@link SimpleDynamicMethod} to this overloaded method's set.
 *
 * @param method the method to add.
 */
-public void addMethod(SimpleDynamicMethod method) {
+void addMethod(SimpleDynamicMethod method) {
 addMethod(method.getTarget());
 }
 /**
 * Add a method to this overloaded method's set.

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

comparison: src/jdk/internal/dynalink/beans/OverloadedDynamicMethod.java

src/jdk/internal/dynalink/beans/OverloadedDynamicMethod.java