jdk-sandbox: comparison jdk/src/share/classes/com/sun/tools/example/debug/expr/LValue.java

equal deleted inserted replaced

-:a437b3f9d7f4
+:6fe31bc95bbc
 (field != null));
 ***/
 return field;
 }
-static List methodsByName(ReferenceType refType, String name, int kind) {
+static List<Method> methodsByName(ReferenceType refType,
-List list = refType.methodsByName(name);
+String name, int kind) {
-Iterator iter = list.iterator();
+List<Method> list = refType.methodsByName(name);
+Iterator<Method> iter = list.iterator();
 while (iter.hasNext()) {
-Method method = (Method)iter.next();
+Method method = iter.next();
 boolean isStatic = method.isStatic();
 if (((kind == STATIC) && !isStatic) ||
 ((kind == INSTANCE) && isStatic)) {
 iter.remove();
 }
 * from the type of the argument value.
 * DIFFERENT means that in at least one pair, the
 * argType is not assignable from the type of the argument value.
 * IE, one is an Apple and the other is an Orange.
 */
-static int argumentsMatch(List argTypes, List arguments) {
+static int argumentsMatch(List<Type> argTypes, List<Value> arguments) {
 if (argTypes.size() != arguments.size()) {
 return DIFFERENT;
 }
-Iterator typeIter = argTypes.iterator();
+Iterator<Type> typeIter = argTypes.iterator();
-Iterator valIter = arguments.iterator();
+Iterator<Value> valIter = arguments.iterator();
 int result = SAME;
 // If any pair aren't the same, change the
 // result to ASSIGNABLE.  If any pair aren't
 // assignable, return DIFFERENT
 while (typeIter.hasNext()) {
-Type argType = (Type)typeIter.next();
+Type argType = typeIter.next();
-Value value = (Value)valIter.next();
+Value value = valIter.next();
 if (value == null) {
 // Null values can be passed to any non-primitive argument
 if (primitiveTypeNames.contains(argType.name())) {
 return DIFFERENT;
 }
 // neither one is primitive.
 if (fromType instanceof ArrayType) {
 return isArrayAssignableTo((ArrayType)fromType, toType);
 }
-List interfaces;
+List<InterfaceType> interfaces;
 if (fromType instanceof ClassType) {
 ClassType superclazz = ((ClassType)fromType).superclass();
 if ((superclazz != null) && isAssignableTo(superclazz, toType)) {
 return true;
 }
 interfaces = ((ClassType)fromType).interfaces();
 } else {
 // fromType must be an InterfaceType
 interfaces = ((InterfaceType)fromType).superinterfaces();
 }
-Iterator iter = interfaces.iterator();
+for (InterfaceType interfaze : interfaces) {
-while (iter.hasNext()) {
-InterfaceType interfaze = (InterfaceType)iter.next();
 if (isAssignableTo(interfaze, toType)) {
 return true;
 }
 }
 return false;
 }
-static Method resolveOverload(List overloads, List arguments)
+static Method resolveOverload(List<Method> overloads,
+List<Value> arguments)
 throws ParseException {
 // If there is only one method to call, we'll just choose
 // that without looking at the args.  If they aren't right
 // the invoke will return a better error message than we
 // could generate here.
 if (overloads.size() == 1) {
-return (Method)overloads.get(0);
+return overloads.get(0);
 }
 // Resolving overloads is beyond the scope of this exercise.
 // So, we will look for a method that matches exactly the
 // types of the arguments.  If we can't find one, then
 // from the arg types, we will use that.  Otherwise,
 // it is an error.  We won't guess which of multiple possible
 // methods to call. And, since casts aren't implemented,
 // the user can't use them to pick a particular overload to call.
 // IE, the user is out of luck in this case.
-Iterator iter = overloads.iterator();
 Method retVal = null;
 int assignableCount = 0;
-while (iter.hasNext()) {
+for (Method mm : overloads) {
-Method mm = (Method)iter.next();
+List<Type> argTypes;
-List argTypes;
 try {
 argTypes = mm.argumentTypes();
 } catch (ClassNotLoadedException ee) {
 // This probably won't happen for the
 // method that we are really supposed to
 private static class LValueInstanceMember extends LValue {
 final ObjectReference obj;
 final ThreadReference thread;
 final Field matchingField;
-final List overloads;
+final List<Method> overloads;
 Method matchingMethod = null;
 List<Value> methodArguments = null;
 LValueInstanceMember(Value value,
 String memberName,
 private static class LValueStaticMember extends LValue {
 final ReferenceType refType;
 final ThreadReference thread;
 final Field matchingField;
-final List overloads;
+final List<Method> overloads;
 Method matchingMethod = null;
 List<Value> methodArguments = null;
 LValueStaticMember(ReferenceType refType,
 String memberName,
 }
 static LValue makeNewObject(VirtualMachine vm,
 ExpressionParser.GetFrame frameGetter,
 String className, List<Value> arguments) throws ParseException {
-List classes = vm.classesByName(className);
+List<ReferenceType> classes = vm.classesByName(className);
 if (classes.size() == 0) {
 throw new ParseException("No class named: " + className);
 }
 if (classes.size() > 1) {
 throw new ParseException("More than one class named: " +
 className);
 }
-ReferenceType refType = (ReferenceType)classes.get(0);
+ReferenceType refType = classes.get(0);
 if (!(refType instanceof ClassType)) {
 throw new ParseException("Cannot create instance of interface " +
 className);
 }
 ClassType classType = (ClassType)refType;
 List<Method> methods = new ArrayList<Method>(classType.methods()); // writable
-Iterator iter = methods.iterator();
+Iterator<Method> iter = methods.iterator();
 while (iter.hasNext()) {
-Method method = (Method)iter.next();
+Method method = iter.next();
 if (!method.isConstructor()) {
 iter.remove();
 }
 }
 Method constructor = LValue.resolveOverload(methods, arguments);
 }
 }
 }
 // check for class name
 while (izer.hasMoreTokens()) {
-List classes = vm.classesByName(first);
+List<ReferenceType> classes = vm.classesByName(first);
 if (classes.size() > 0) {
 if (classes.size() > 1) {
 throw new ParseException("More than one class named: " +
 first);
 } else {
-ReferenceType refType = (ReferenceType)classes.get(0);
+ReferenceType refType = classes.get(0);
 LValue lval = new LValueStaticMember(refType,
 izer.nextToken(), thread);
 return nFields(lval, izer, thread);
 }
 }

changeset 51	6fe31bc95bbc
parent 2	90ce3da70b43
child 715	f16baef3a20e