/hg/icedtea-web: Rewrite of MethodOverloadResolver
adomurad at icedtea.classpath.org
adomurad at icedtea.classpath.org
Tue Apr 23 08:20:49 PDT 2013
changeset 66b641f365b5 in /hg/icedtea-web
details: http://icedtea.classpath.org/hg/icedtea-web?cmd=changeset;node=66b641f365b5
author: Adam Domurad <adomurad at redhat.com>
date: Tue Apr 23 11:10:24 2013 -0400
Rewrite of MethodOverloadResolver
diffstat:
ChangeLog | 14 +
plugin/icedteanp/java/sun/applet/MethodOverloadResolver.java | 941 +++------
plugin/icedteanp/java/sun/applet/PluginAppletSecurityContext.java | 80 +-
tests/netx/unit/sun/applet/MethodOverloadResolverTest.java | 383 ++++
4 files changed, 793 insertions(+), 625 deletions(-)
diffs (truncated from 1615 to 500 lines):
diff -r 50295be3e2da -r 66b641f365b5 ChangeLog
--- a/ChangeLog Tue Apr 23 10:18:52 2013 -0400
+++ b/ChangeLog Tue Apr 23 11:10:24 2013 -0400
@@ -1,3 +1,17 @@
+2013-04-23 Adam Domurad <adomurad at redhat.com>
+
+ Rewrite of MethodOverloadResolver with detailed unittests.
+ * plugin/icedteanp/java/sun/applet/MethodOverloadResolver.java:
+ Rewritten to reduce duplicated code, fix very subtle bugs in
+ never-tested codepaths, obey spec properly. Introduced new helper types
+ where Object[] arrays with special-meaning positions were passed
+ around.
+ * plugin/icedteanp/java/sun/applet/PluginAppletSecurityContext.java:
+ Updated to work with newly introduced types / refactored overload
+ resolver.
+ * tests/netx/unit/sun/applet/MethodOverloadResolverTest.java: In-depth
+ unit tests of hairy details of method overloading in JS<->Java.
+
2013-04-23 Omair Majid <omajid at redhat.com>
PR1299
diff -r 50295be3e2da -r 66b641f365b5 plugin/icedteanp/java/sun/applet/MethodOverloadResolver.java
--- a/plugin/icedteanp/java/sun/applet/MethodOverloadResolver.java Tue Apr 23 10:18:52 2013 -0400
+++ b/plugin/icedteanp/java/sun/applet/MethodOverloadResolver.java Tue Apr 23 11:10:24 2013 -0400
@@ -41,449 +41,403 @@
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import netscape.javascript.JSObject;
/*
* This class resolved overloaded methods in Java objects using a cost
- * based-approach as described here:
+ * based-approach described here:
*
- * http://java.sun.com/javase/6/webnotes/6u10/plugin2/liveconnect/#OVERLOADED_METHODS
+ * http://jdk6.java.net/plugin2/liveconnect/#OVERLOADED_METHODS
*/
public class MethodOverloadResolver {
+ static final int NUMERIC_SAME_COST = 1;
+ static final int NULL_TO_OBJECT_COST = 2;
+ static final int CLASS_SAME_COST = 3;
+ static final int NUMERIC_CAST_COST = 4;
+ static final int NUMERIC_BOOLEAN_COST = 5;
- private static boolean debugging = false;
+ static final int STRING_NUMERIC_CAST_COST = 5;
- public static void main(String[] args) {
- testMethodResolver();
+ static final int CLASS_SUPERCLASS_COST = 6;
+
+ static final int CLASS_STRING_COST = 7;
+ static final int JSOBJECT_TO_ARRAY_COST = CLASS_STRING_COST;
+ static final int ARRAY_CAST_COST = 8;
+
+ /* A method signature with its casted parameters
+ * We pretend a Constructor is a normal 'method' for ease of code reuse */
+ static class ResolvedMethod {
+
+ private java.lang.reflect.AccessibleObject method;
+ private Object[] castedParameters;
+ private int cost;
+
+ public ResolvedMethod(int cost, java.lang.reflect.AccessibleObject method, Object[] castedParameters) {
+ this.cost = cost;
+ this.method = method;
+ this.castedParameters = castedParameters;
+ }
+
+ java.lang.reflect.AccessibleObject getAccessibleObject() {
+ return method;
+ }
+
+ public Method getMethod() {
+ return (Method)method;
+ }
+
+ public Constructor<?> getConstructor() {
+ return (Constructor<?>)method;
+ }
+
+ public Object[] getCastedParameters() {
+ return castedParameters;
+ }
+
+ public int getCost() {
+ return cost;
+ }
}
- public static void testMethodResolver() {
- debugging = true;
+ /* A cast with an associated 'cost', used for picking method overloads */
+ static class WeightedCast {
- ArrayList<Object[]> list = new ArrayList<Object[]>(20);
- FooClass fc = new FooClass();
+ private int cost;
+ private Object castedObject;
- // Numeric to java primitive
- // foo_i has Integer and int params
- String s1 = "foo_string_int(S,I)";
- String s1a = "foo_string_int(S,S)";
- Object[] o1 = { fc.getClass(), "foo_string_int", "blah", 42 };
- list.add(o1);
- Object[] o1a = { fc.getClass(), "foo_string_int", "blah", "42.42" };
- list.add(o1a);
-
- // Null to non-primitive type
- // foo_i is overloaded with Integer and int
- String s2 = "foo_string_int(N)";
- Object[] o2 = { fc.getClass(), "foo_string_int", "blah", null };
- list.add(o2);
-
- // foo_jsobj is overloaded with JSObject and String params
- String s3 = "foo_jsobj(LLowCostSignatureComputer/JSObject;)";
- Object[] o3 = { fc.getClass(), "foo_jsobj", new JSObject() };
- list.add(o3);
-
- // foo_classtype is overloaded with Number and Integer
- String s4 = "foo_classtype(Ljava/lang/Integer;)";
- Object[] o4 = { fc.getClass(), "foo_classtype", 42 };
- list.add(o4);
-
- // foo_multiprim is overloaded with int, long and float types
- String s5 = "foo_multiprim(I)";
- String s6 = "foo_multiprim(F)";
- String s6a = "foo_multiprim(D)";
-
- Object[] o5 = { fc.getClass(), "foo_multiprim", new Integer(42) };
- Object[] o6 = { fc.getClass(), "foo_multiprim", new Float(42.42) };
- Object[] o6a = { fc.getClass(), "foo_multiprim", new Double(42.42) };
- list.add(o5);
- list.add(o6);
- list.add(o6a);
-
- // foo_float has float, String and JSObject type
- String s7 = "foo_float(I)";
- Object[] o7 = { fc.getClass(), "foo_float", new Integer(42) };
- list.add(o7);
-
- // foo_multiprim(float) is what this should convert
- String s8 = "foo_float(S)";
- Object[] o8 = { fc.getClass(), "foo_float", "42" };
- list.add(o8);
-
- // foo_class is overloaded with BarClass 2 and 3
- String s9 = "foo_class(LLowCostSignatureComputer/BarClass3;)";
- Object[] o9 = { fc.getClass(), "foo_class", new BarClass3() };
- list.add(o9);
-
- // foo_strandbyteonly takes string and byte
- String s10 = "foo_strandbyteonly(I)";
- Object[] o10 = { fc.getClass(), "foo_strandbyteonly", 42 };
- list.add(o10);
-
- // JSOBject to string
- String s11 = "foo_strandbyteonly(LLowCostSignatureComputer/JSObject;)";
- Object[] o11 = { fc.getClass(), "foo_strandbyteonly", new JSObject() };
- list.add(o11);
-
- // jsobject to string and int to float
- String s12 = "foo_str_and_float(S,I)";
- Object[] o12 = { fc.getClass(), "foo_str_and_float", new JSObject(), new Integer(42) };
- list.add(o12);
-
- // call for which no match will be found
- String s13 = "foo_int_only(JSObject)";
- Object[] o13 = { fc.getClass(), "foo_int_only", new JSObject() };
- list.add(o13);
-
- // method with no args
- String s14 = "foo_noargs()";
- Object[] o14 = { fc.getClass(), "foo_noargs" };
- list.add(o14);
-
- // method which takes a primitive bool, given a Boolean
- String s15 = "foo_boolonly()";
- Object[] o15 = { fc.getClass(), "foo_boolonly", new Boolean(true) };
- list.add(o15);
-
- for (Object[] o : list) {
- Object[] methodAndArgs = getMatchingMethod(o);
- if (debugging)
- if (methodAndArgs != null)
- System.out.println("Best match: " + methodAndArgs[0] + "\n");
- else
- System.out.println("No match found.\n");
-
+ public WeightedCast(int cost, Object castedObject) {
+ this.cost = cost;
+ this.castedObject = castedObject;
}
+ public Object getCastedObject() {
+ return castedObject;
+ }
+
+ public int getCost() {
+ return cost;
+ }
+ }
+
+
+ public static ResolvedMethod getBestMatchMethod(Class<?> c, String methodName, Object[] args) {
+ Method[] matchingMethods = getMatchingMethods(c, methodName, args.length);
+
+ if (PluginDebug.DEBUG) { /* avoid toString if not needed */
+ PluginDebug.debug("getMatchingMethod called with: "
+ + Arrays.toString(args));
+ }
+
+ return getBestOverloadMatch(c, args, matchingMethods);
+ }
+
+ public static ResolvedMethod getBestMatchConstructor(Class<?> c, Object[] args) {
+ Constructor<?>[] matchingConstructors = getMatchingConstructors(c, args.length);
+
+ if (PluginDebug.DEBUG) { /* avoid toString if not needed */
+ PluginDebug.debug("getMatchingConstructor called with: "
+ + Arrays.toString(args));
+ }
+
+ return getBestOverloadMatch(c, args, matchingConstructors);
}
/*
- * Cost based overload resolution algorithm based on cost rules specified here:
- *
- * http://java.sun.com/javase/6/webnotes/6u10/plugin2/liveconnect/#OVERLOADED_METHODS
+ * Get best-matching method based on a cost based overload resolution
+ * algorithm is used, described here:
+ *
+ * http://jdk6.java.net/plugin2/liveconnect/#OVERLOADED_METHODS
+ *
+ * Note that we consider Constructor's to be 'methods' for convenience. We
+ * use the common parent class of Method/Constructor, 'AccessibleObject'
+ *
+ * NB: Although the spec specifies that ambiguous method calls (ie, same
+ * cost) should throw errors, we simply pick the first overload for
+ * simplicity. Method overrides should not be doing wildly different things
+ * anyway.
*/
-
- public static Object[] getMatchingMethod(Object[] callList) {
- Object[] ret = null;
- Class<?> c = (Class<?>) callList[0];
- String methodName = (String) callList[1];
-
- Method[] matchingMethods = getMatchingMethods(c, methodName, callList.length - 2);
-
- if (debugging)
- System.out.println("getMatchingMethod called with: " + printList(callList));
+ static ResolvedMethod getBestOverloadMatch(Class<?> c, Object[] args,
+ java.lang.reflect.AccessibleObject[] candidates) {
int lowestCost = Integer.MAX_VALUE;
+ java.lang.reflect.AccessibleObject cheapestMethod = null;
+ Object[] cheapestArgs = null;
+ boolean ambiguous = false;
- for (Method matchingMethod : matchingMethods) {
+ methodLoop:
+ for (java.lang.reflect.AccessibleObject candidate : candidates) {
+ int methodCost = 0;
- int methodCost = 0;
- Class[] paramTypes = matchingMethod.getParameterTypes();
- Object[] methodAndArgs = new Object[paramTypes.length + 1];
- methodAndArgs[0] = matchingMethod;
+ Class<?>[] paramTypes = getParameterTypesFor(candidate);
+ Object[] castedArgs = new Object[paramTypes.length];
// Figure out which of the matched methods best represents what we
// want
for (int i = 0; i < paramTypes.length; i++) {
Class<?> paramTypeClass = paramTypes[i];
- Object suppliedParam = callList[i + 2];
+ Object suppliedParam = args[i];
Class<?> suppliedParamClass = suppliedParam != null ? suppliedParam
- .getClass()
- : null;
+ .getClass() : null;
- Object[] costAndCastedObj = getCostAndCastedObject(
+ WeightedCast weightedCast = getCostAndCastedObject(
suppliedParam, paramTypeClass);
- methodCost += (Integer) costAndCastedObj[0];
- if ((Integer) costAndCastedObj[0] < 0)
- break;
+ if (weightedCast == null) {
+ continue methodLoop; // Cannot call this constructor!
+ }
- Object castedObj = paramTypeClass.isPrimitive() ? costAndCastedObj[1]
- : paramTypeClass.cast(costAndCastedObj[1]);
- methodAndArgs[i + 1] = castedObj;
+ methodCost += weightedCast.getCost();
- Class<?> castedObjClass = castedObj == null ? null : castedObj
- .getClass();
- Boolean castedObjIsPrim = castedObj == null ? null : castedObj
- .getClass().isPrimitive();
+ Object castedObj = paramTypeClass.isPrimitive() ?
+ weightedCast.getCastedObject()
+ : paramTypeClass.cast(weightedCast.getCastedObject());
- if (debugging)
- System.out.println("Param " + i + " of method "
- + matchingMethod + " has cost "
- + (Integer) costAndCastedObj[0]
+ castedArgs[i] = castedObj;
+
+ Class<?> castedObjClass = castedObj == null ? null : castedObj.getClass();
+ boolean castedObjIsPrim = castedObj == null ? false : castedObj.getClass().isPrimitive();
+
+ if (PluginDebug.DEBUG) { /* avoid toString if not needed */
+ PluginDebug.debug("Param " + i + " of method " + candidate
+ + " has cost " + weightedCast.getCost()
+ " original param type " + suppliedParamClass
+ " casted to " + castedObjClass + " isPrimitive="
+ castedObjIsPrim + " value " + castedObj);
+ }
}
- if ((methodCost > 0 && methodCost < lowestCost) ||
- paramTypes.length == 0) {
- ret = methodAndArgs;
- lowestCost = methodCost;
+ if (methodCost <= lowestCost) {
+ if (methodCost < lowestCost
+ || argumentsAreSubclassesOf(castedArgs, cheapestArgs)) {
+ lowestCost = methodCost;
+ cheapestArgs = castedArgs;
+ cheapestMethod = candidate;
+ ambiguous = false;
+ } else {
+ ambiguous = true;
+ }
}
}
- return ret;
+ // The spec says we should error out if the method call is ambiguous
+ // Instead we will report it in debug output
+ if (ambiguous) {
+ PluginDebug.debug("*** Warning: Ambiguous overload of ", c.getClass(), "#", cheapestMethod, "!");
+ }
+
+ return new ResolvedMethod(lowestCost, cheapestMethod, cheapestArgs);
}
- public static Object[] getMatchingConstructor(Object[] callList) {
- Object[] ret = null;
- Class<?> c = (Class<?>) callList[0];
+ public static WeightedCast getCostAndCastedObject(Object suppliedParam,
+ Class<?> paramTypeClass) {
+ Class<?> suppliedParamClass = suppliedParam != null ? suppliedParam
+ .getClass() : null;
- Constructor[] matchingConstructors = getMatchingConstructors(c, callList.length - 1);
+ boolean suppliedParamIsArray = suppliedParamClass != null
+ && suppliedParamClass.isArray();
- if (debugging)
- System.out.println("getMatchingConstructor called with: " + printList(callList));
-
- int lowestCost = Integer.MAX_VALUE;
-
- for (Constructor matchingConstructor : matchingConstructors) {
-
- int constructorCost = 0;
- Class<?>[] paramTypes = matchingConstructor.getParameterTypes();
- Object[] constructorAndArgs = new Object[paramTypes.length + 1];
- constructorAndArgs[0] = matchingConstructor;
-
- // Figure out which of the matched methods best represents what we
- // want
- for (int i = 0; i < paramTypes.length; i++) {
- Class<?> paramTypeClass = paramTypes[i];
- Object suppliedParam = callList[i + 1];
- Class suppliedParamClass = suppliedParam != null ? suppliedParam
- .getClass()
- : null;
-
- Object[] costAndCastedObj = getCostAndCastedObject(
- suppliedParam, paramTypeClass);
- constructorCost += (Integer) costAndCastedObj[0];
-
- if ((Integer) costAndCastedObj[0] < 0)
- break;
-
- Object castedObj = paramTypeClass.isPrimitive() ? costAndCastedObj[1]
- : paramTypeClass.cast(costAndCastedObj[1]);
- constructorAndArgs[i + 1] = castedObj;
-
- Class<?> castedObjClass = castedObj == null ? null : castedObj
- .getClass();
- Boolean castedObjIsPrim = castedObj == null ? null : castedObj
- .getClass().isPrimitive();
-
- if (debugging)
- System.out.println("Param " + i + " of constructor "
- + matchingConstructor + " has cost "
- + (Integer) costAndCastedObj[0]
- + " original param type " + suppliedParamClass
- + " casted to " + castedObjClass + " isPrimitive="
- + castedObjIsPrim + " value " + castedObj);
+ if (suppliedParamIsArray) {
+ if (paramTypeClass.isArray()) {
+ return getArrayToArrayCastWeightedCost(suppliedParam,
+ paramTypeClass);
}
- if ((constructorCost > 0 && constructorCost < lowestCost) ||
- paramTypes.length == 0) {
- ret = constructorAndArgs;
- lowestCost = constructorCost;
+ // Target type must be an array, Object or String
+ // If it an object, we return "as is" [Everything can be narrowed to an
+ // object, cost=CLASS_SUPERCLASS_COST]
+ // If it is a string, we need to convert according to the JS engine
+ // rules
+ if (paramTypeClass != String.class
+ && paramTypeClass != Object.class) {
+ return null;
}
- }
-
- return ret;
- }
-
- public static Object[] getCostAndCastedObject(Object suppliedParam, Class<?> paramTypeClass) {
-
- Object[] ret = new Object[2];
- Integer cost = new Integer(0);
- Object castedObj;
-
- Class<?> suppliedParamClass = suppliedParam != null ? suppliedParam.getClass() : null;
-
- // Either both are an array, or neither are
- boolean suppliedParamIsArray = suppliedParamClass != null && suppliedParamClass.isArray();
- if (paramTypeClass.isArray() != suppliedParamIsArray &&
- !paramTypeClass.equals(Object.class) &&
- !paramTypeClass.equals(String.class)) {
- ret[0] = Integer.MIN_VALUE; // Not allowed
- ret[1] = suppliedParam;
- return ret;
- }
-
- // If param type is an array, supplied obj must be an array, Object or String (guaranteed by checks above)
- // If it is an array, we need to copy/cast as we scan the array
- // If it an object, we return "as is" [Everything can be narrowed to an object, cost=6]
- // If it is a string, we need to convert according to the JS engine rules
-
- if (paramTypeClass.isArray()) {
-
- Object newArray = Array.newInstance(paramTypeClass.getComponentType(), Array.getLength(suppliedParam));
- for (int i = 0; i < Array.getLength(suppliedParam); i++) {
- Object original = Array.get(suppliedParam, i);
-
- // When dealing with arrays, we represent empty slots with
- // null. We need to convert this to 0 before recursive
- // calling, since normal transformation does not allow
- // null -> primitive
-
- if (original == null && paramTypeClass.getComponentType().isPrimitive())
- original = 0;
-
- Object[] costAndCastedObject = getCostAndCastedObject(original, paramTypeClass.getComponentType());
-
- if ((Integer) costAndCastedObject[0] < 0) {
- ret[0] = Integer.MIN_VALUE; // Not allowed
- ret[1] = suppliedParam;
- return ret;
- }
-
- Array.set(newArray, i, costAndCastedObject[1]);
+ if (paramTypeClass.equals(String.class)) {
+ return new WeightedCast(ARRAY_CAST_COST,
+ arrayToJavascriptStyleString(suppliedParam));
}
-
- ret[0] = 9;
- ret[1] = newArray;
- return ret;
- }
-
- if (suppliedParamIsArray && paramTypeClass.equals(String.class)) {
-
- ret[0] = 9;
- ret[1] = getArrayAsString(suppliedParam);
More information about the distro-pkg-dev
mailing list