Merged gcj-eclipse branch to trunk.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@120621 138bc75d-0d04-0410-961f-82ee72b054a4

7 files changed, 459 insertions, 68 deletions

diff --git a/libjava/classpath/gnu/java/lang/InstrumentationImpl.java b/libjava/classpath/gnu/java/lang/InstrumentationImpl.java
index 7bfed458245..2425b35c8a9 100644
--- a/libjava/classpath/gnu/java/lang/InstrumentationImpl.java
+++ b/libjava/classpath/gnu/java/lang/InstrumentationImpl.java
@@ -1,6 +1,6 @@
 /* InstrumentationImpl.java -- GNU implementation of
    java.lang.instrument.Instrumentation
-   Copyright (C) 2005  Free Software Foundation, Inc.
+   Copyright (C) 2005, 2006  Free Software Foundation, Inc.
 
 This file is part of GNU Classpath.
 
@@ -63,11 +63,11 @@ public final class InstrumentationImpl implements Instrumentation
 {
 
   /* List of transformers */
-  /* FIXME[GENERICS]: Should be ClassFileTransformer list */
-  private ArrayList transformers = new ArrayList();
+  private ArrayList<ClassFileTransformer> transformers =
+    new ArrayList<ClassFileTransformer>();
 
   
-  private InstrumentationImpl()
+  InstrumentationImpl()
   {
   }
 
@@ -210,9 +210,8 @@ public final class InstrumentationImpl implements Instrumentation
    * 
    * @return the new class file
    */
-  /* FIXME[GENERICS]: Should be Class<?> */
   public byte[] callTransformers(ClassLoader loader, String className,
-				 Class classBeingRedefined, ProtectionDomain protectionDomain, 
+				 Class<?> classBeingRedefined, ProtectionDomain protectionDomain, 
 				 byte[] classfileBuffer)
   {
     byte[] newBuffer = null;
@@ -220,11 +219,10 @@ public final class InstrumentationImpl implements Instrumentation
     ClassFileTransformer current;
     synchronized (transformers)
       {
-        Iterator i = transformers.iterator();
+        Iterator<ClassFileTransformer> i = transformers.iterator();
         while (i.hasNext())
           {
-	    /* FIXME[GENERICS]: Remove cast */
-            current = (ClassFileTransformer) i.next();
+            current = i.next();
             try
               {
                 newBuffer = current.transform(loader, className,
diff --git a/libjava/classpath/gnu/java/lang/management/BeanImpl.java b/libjava/classpath/gnu/java/lang/management/BeanImpl.java
index 24572a25d5d..e5b47181273 100644
--- a/libjava/classpath/gnu/java/lang/management/BeanImpl.java
+++ b/libjava/classpath/gnu/java/lang/management/BeanImpl.java
@@ -39,9 +39,50 @@ package gnu.java.lang.management;
 
 import java.lang.management.ManagementPermission;
 
+import java.lang.reflect.Array;
+import java.lang.reflect.Method;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.TypeVariable;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import javax.management.AttributeNotFoundException;
+import javax.management.MBeanAttributeInfo;
+import javax.management.MBeanConstructorInfo;
+import javax.management.MBeanException;
+import javax.management.MBeanInfo;
+import javax.management.MBeanOperationInfo;
+import javax.management.MBeanParameterInfo;
+import javax.management.MBeanInfo;
 import javax.management.NotCompliantMBeanException;
+import javax.management.ReflectionException;
 import javax.management.StandardMBean;
 
+import javax.management.openmbean.ArrayType;
+import javax.management.openmbean.CompositeData;
+import javax.management.openmbean.CompositeDataSupport;
+import javax.management.openmbean.CompositeType;
+import javax.management.openmbean.OpenDataException;
+import javax.management.openmbean.OpenMBeanAttributeInfo;
+import javax.management.openmbean.OpenMBeanAttributeInfoSupport;
+import javax.management.openmbean.OpenMBeanConstructorInfo;
+import javax.management.openmbean.OpenMBeanConstructorInfoSupport;
+import javax.management.openmbean.OpenMBeanInfo;
+import javax.management.openmbean.OpenMBeanInfoSupport;
+import javax.management.openmbean.OpenMBeanOperationInfo;
+import javax.management.openmbean.OpenMBeanOperationInfoSupport;
+import javax.management.openmbean.OpenMBeanParameterInfo;
+import javax.management.openmbean.OpenMBeanParameterInfoSupport;
+import javax.management.openmbean.OpenType;
+import javax.management.openmbean.SimpleType;
+import javax.management.openmbean.TabularData;
+import javax.management.openmbean.TabularDataSupport;
+import javax.management.openmbean.TabularType;
+
 /**
  * A common superclass for bean implementations.
  *
@@ -51,7 +92,12 @@ import javax.management.StandardMBean;
 public class BeanImpl
   extends StandardMBean
 {
- 
+
+  /**
+   * Cached open bean information.
+   */
+  private OpenMBeanInfo openInfo;
+
   /**
    * Constructs a new <code>BeanImpl</code>.
    *
@@ -67,6 +113,71 @@ public class BeanImpl
     super(iface);
   }
 
+  protected void cacheMBeanInfo(MBeanInfo info)
+  {
+    if (info == null)
+      return;
+    try
+      {
+	MBeanAttributeInfo[] oldA = info.getAttributes();
+	OpenMBeanAttributeInfo[] attribs =
+	  new OpenMBeanAttributeInfoSupport[oldA.length];
+	for (int a = 0; a < oldA.length; ++a)
+	  {
+	    OpenMBeanParameterInfo param = translate(oldA[a].getType());
+	    if (param.getMinValue() == null)
+	      {
+		Object[] lv;
+		if (param.getLegalValues() == null)
+		  lv = null;
+		else
+		  lv = param.getLegalValues().toArray();
+		attribs[a] = new OpenMBeanAttributeInfoSupport(oldA[a].getName(),
+							       oldA[a].getDescription(),
+							       param.getOpenType(),
+							       oldA[a].isReadable(),
+							       oldA[a].isWritable(),
+							       oldA[a].isIs(),
+							       param.getDefaultValue(),
+							       lv);
+	      }
+	    else
+	      attribs[a] = new OpenMBeanAttributeInfoSupport(oldA[a].getName(),
+							     oldA[a].getDescription(),
+							     param.getOpenType(),
+							     oldA[a].isReadable(),
+							     oldA[a].isWritable(),
+							     oldA[a].isIs(),
+							     param.getDefaultValue(),
+							     param.getMinValue(),
+							     param.getMaxValue());
+	  }
+	MBeanConstructorInfo[] oldC = info.getConstructors();
+	OpenMBeanConstructorInfo[] cons = new OpenMBeanConstructorInfoSupport[oldC.length];
+	for (int a = 0; a < oldC.length; ++a)
+	  cons[a] =
+	    new OpenMBeanConstructorInfoSupport(oldC[a].getName(),
+						oldC[a].getDescription(),
+						translateSignature(oldC[a].getSignature()));
+	MBeanOperationInfo[] oldO = info.getOperations();
+	OpenMBeanOperationInfo[] ops = new OpenMBeanOperationInfoSupport[oldO.length];
+	for (int a = 0; a < oldO.length; ++a)
+	  ops[a] =
+	new OpenMBeanOperationInfoSupport(oldO[a].getName(),
+					  oldO[a].getDescription(),
+					  translateSignature(oldO[a].getSignature()),
+					  translate(oldO[a].getReturnType()).getOpenType(),
+					  oldO[a].getImpact());
+	openInfo = new OpenMBeanInfoSupport(info.getClassName(), info.getDescription(),
+					    attribs, cons, ops, info.getNotifications());
+      }
+    catch (OpenDataException e)
+      {
+	throw (InternalError) (new InternalError("A problem occurred creating the open type " +
+						 "descriptors.").initCause(e));
+      }
+  }
+
   protected void checkMonitorPermissions()
   {
     SecurityManager sm = System.getSecurityManager();
@@ -81,4 +192,328 @@ public class BeanImpl
       sm.checkPermission(new ManagementPermission("control"));
   }
 
+  public Object getAttribute(String attribute)
+    throws AttributeNotFoundException, MBeanException,
+	   ReflectionException
+  {
+    Object value = super.getAttribute(attribute);
+    if (value instanceof Enum)
+      return ((Enum) value).name();
+    Class vClass = value.getClass();
+    if (vClass.isArray())
+      return value;
+    String cName = vClass.getName();
+    String[] allowedTypes = OpenType.ALLOWED_CLASSNAMES;
+    for (int a = 0; a < allowedTypes.length; ++a)
+      if (cName.equals(allowedTypes[a]))
+	return value;
+    if (value instanceof List)
+      {
+	List l = (List) value;
+	Class e = null;
+	TypeVariable[] vars = vClass.getTypeParameters();
+	for (int a = 0; a < vars.length; ++a)
+	  if (vars[a].getName().equals("E"))
+	    e = (Class) vars[a].getGenericDeclaration();
+	if (e == null)
+	  e = Object.class;
+	Object[] array = (Object[]) Array.newInstance(e, l.size());
+	return l.toArray(array);
+      }
+    OpenMBeanInfo info = (OpenMBeanInfo) getMBeanInfo();
+    OpenMBeanAttributeInfo[] attribs =
+      (OpenMBeanAttributeInfo[]) info.getAttributes();
+    OpenType type = null;
+    for (int a = 0; a < attribs.length; ++a)
+      if (attribs[a].getName().equals("attribute"))
+	type = attribs[a].getOpenType();
+    if (value instanceof Map)
+      {
+	TabularType ttype = (TabularType) type;
+	TabularData data = new TabularDataSupport(ttype);
+	Iterator it = ((Map) value).entrySet().iterator();
+	while (it.hasNext())
+	  {
+	    Map.Entry entry = (Map.Entry) it.next();
+	    try 
+	      {
+		data.put(new CompositeDataSupport(ttype.getRowType(),
+						  new String[] { 
+						    "key", 
+						    "value" 
+						  },
+						  new Object[] { 
+						    entry.getKey(),
+						    entry.getValue()
+						  }));
+	      }
+	    catch (OpenDataException e)
+	      {
+		throw (InternalError) (new InternalError("A problem occurred " +
+							 "converting the map " +
+							 "to a composite data " +
+							 "structure.").initCause(e));
+	      }
+	  }
+	return data;
+      }
+    CompositeType cType = (CompositeType) type;
+    Set names = cType.keySet();
+    Iterator it = names.iterator();
+    List values = new ArrayList(names.size());
+    while (it.hasNext())
+      {
+	String field = (String) it.next();
+	Method getter = null;
+	try 
+	  {
+	    getter = vClass.getMethod("get" + field, null);
+	  }
+	catch (NoSuchMethodException e)
+	  {
+	    /* Ignored; the type tells us it's there. */
+	  }
+	try
+	  {
+	    values.add(getter.invoke(value, null));
+	  }
+	catch (IllegalAccessException e)
+	  {
+	    throw new ReflectionException(e, "Failed to retrieve " + field);
+	  }
+	catch (IllegalArgumentException e)
+	  {
+	    throw new ReflectionException(e, "Failed to retrieve " + field);
+	  }
+	catch (InvocationTargetException e)
+	  {
+	    throw new MBeanException((Exception) e.getCause(),
+				     "The getter of " + field +
+				     " threw an exception");
+	  }
+      }
+    try
+      {
+	return new CompositeDataSupport(cType, 
+					(String[]) 
+					names.toArray(new String[names.size()]),
+					values.toArray());
+      }
+    catch (OpenDataException e)
+      {
+	throw (InternalError) (new InternalError("A problem occurred " +
+						 "converting the value " +
+						 "to a composite data " +
+						 "structure.").initCause(e));
+      }
+  }
+  
+  protected MBeanInfo getCachedMBeanInfo()
+  {
+    return (MBeanInfo) openInfo;
+  }
+
+  public MBeanInfo getMBeanInfo()
+  {
+    super.getMBeanInfo();
+    return getCachedMBeanInfo();
+  }
+
+  private OpenType getTypeFromClass(Class c)
+    throws OpenDataException
+  {
+    return translate(c.getName()).getOpenType();
+  }
+
+  private OpenMBeanParameterInfo[] translateSignature(MBeanParameterInfo[] oldS)
+    throws OpenDataException
+  {
+    OpenMBeanParameterInfo[] sig = new OpenMBeanParameterInfoSupport[oldS.length];
+    for (int a = 0; a < oldS.length; ++a)
+      {
+	OpenMBeanParameterInfo param = translate(oldS[a].getType());
+	if (param.getMinValue() == null)
+	  {
+	    Object[] lv;
+	    if (param.getLegalValues() == null)
+	      lv = null;
+	    else
+	      lv = param.getLegalValues().toArray();
+	    sig[a] = new OpenMBeanParameterInfoSupport(oldS[a].getName(),
+						       oldS[a].getDescription(),
+						       param.getOpenType(),
+						       param.getDefaultValue(),
+						       lv);
+	  }
+	else
+	  sig[a] = new OpenMBeanParameterInfoSupport(oldS[a].getName(),
+						     oldS[a].getDescription(),
+						     param.getOpenType(),
+						     param.getDefaultValue(),
+						     param.getMinValue(),
+						     param.getMaxValue());
+      }
+    return sig;
+  }
+
+  private OpenMBeanParameterInfo translate(String type)
+    throws OpenDataException
+  {
+    if (type.equals("boolean") || type.equals(Boolean.class.getName()))
+      return new OpenMBeanParameterInfoSupport("TransParam",
+					       "Translated parameter",
+					       SimpleType.BOOLEAN,
+					       null,
+					       new Object[] {
+						 Boolean.TRUE,
+						 Boolean.FALSE
+					       });
+    if (type.equals("byte") || type.equals(Byte.class.getName()))
+      return new OpenMBeanParameterInfoSupport("TransParam",
+					       "Translated parameter",
+					       SimpleType.BYTE,
+					       null,
+					       Byte.valueOf(Byte.MIN_VALUE),
+					       Byte.valueOf(Byte.MAX_VALUE));
+    if (type.equals("char") || type.equals(Character.class.getName()))
+      return new OpenMBeanParameterInfoSupport("TransParam",
+					       "Translated parameter",
+					       SimpleType.CHARACTER,
+					       null,
+					       Character.valueOf(Character.MIN_VALUE),
+					       Character.valueOf(Character.MAX_VALUE));
+    if (type.equals("double") || type.equals(Double.class.getName()))
+      return new OpenMBeanParameterInfoSupport("TransParam",
+					       "Translated parameter",
+					       SimpleType.DOUBLE,
+					       null,
+					       Double.valueOf(Double.MIN_VALUE),
+					       Double.valueOf(Double.MAX_VALUE));
+    if (type.equals("float") || type.equals(Float.class.getName()))
+      return new OpenMBeanParameterInfoSupport("TransParam",
+					       "Translated parameter",
+					       SimpleType.FLOAT,
+					       null,
+					       Float.valueOf(Float.MIN_VALUE),
+					       Float.valueOf(Float.MAX_VALUE));
+    if (type.equals("int") || type.equals(Integer.class.getName()))
+      return new OpenMBeanParameterInfoSupport("TransParam",
+					       "Translated parameter",
+					       SimpleType.INTEGER,
+					       null,
+					       Integer.valueOf(Integer.MIN_VALUE),
+					       Integer.valueOf(Integer.MAX_VALUE));
+    if (type.equals("long") || type.equals(Long.class.getName()))
+      return new OpenMBeanParameterInfoSupport("TransParam",
+					       "Translated parameter",
+					       SimpleType.LONG,
+					       null,
+					       Long.valueOf(Long.MIN_VALUE),
+					       Long.valueOf(Long.MAX_VALUE));
+    if (type.equals("short") || type.equals(Short.class.getName()))
+      return new OpenMBeanParameterInfoSupport("TransParam",
+					       "Translated parameter",
+					       SimpleType.SHORT,
+					       null,
+					       Short.valueOf(Short.MIN_VALUE),
+					       Short.valueOf(Short.MAX_VALUE));
+    if (type.equals(String.class.getName()))
+      return new OpenMBeanParameterInfoSupport("TransParam",
+					       "Translated parameter",
+					       SimpleType.STRING);
+    if (type.equals("void"))
+      return new OpenMBeanParameterInfoSupport("TransParam",
+					       "Translated parameter",
+					       SimpleType.VOID);
+    if (type.startsWith("java.util.Map"))
+      {
+	int lparam = type.indexOf("<");
+	int comma = type.indexOf(",", lparam);
+	int rparam = type.indexOf(">", comma);
+	String key = type.substring(lparam + 1, comma).trim();
+	OpenType k = translate(key).getOpenType();
+	OpenType v = translate(type.substring(comma + 1, rparam).trim()).getOpenType(); 
+ 	CompositeType ctype = new CompositeType(Map.class.getName(), Map.class.getName(),
+						new String[] { "key", "value" },
+						new String[] { "Map key", "Map value"},
+						new OpenType[] { k, v});
+	TabularType ttype = new TabularType(key, key, ctype,
+					    new String[] { "key" });
+	return new OpenMBeanParameterInfoSupport("TransParam",
+						 "Translated parameter",
+						 ttype);
+      }
+    if (type.startsWith("java.util.List"))
+      {
+	int lparam = type.indexOf("<");
+	int rparam = type.indexOf(">");
+       	OpenType e = translate(type.substring(lparam + 1, rparam).trim()).getOpenType();
+	return new OpenMBeanParameterInfoSupport("TransParam",
+						 "Translated parameter",
+						 new ArrayType(1, e)
+						 );
+      }	
+    Class c;
+    try
+      {
+	c = Class.forName(type);
+      }
+    catch (ClassNotFoundException e)
+      {
+	throw (InternalError)
+	  (new InternalError("The class for a type used in a management bean " +
+			     "could not be loaded.").initCause(e));
+      }
+    if (c.isEnum())
+      {
+	Object[] values = c.getEnumConstants();
+	String[] names = new String[values.length];
+	for (int a = 0; a < values.length; ++a)
+	  names[a] = values[a].toString();
+	return new OpenMBeanParameterInfoSupport("TransParam",
+						 "Translated parameter",
+						 SimpleType.STRING,
+						 null,
+						 (Object[]) names);
+      }
+    try
+      {
+	c.getMethod("from", new Class[] { CompositeData.class });
+	Method[] methods = c.getMethods();
+	List names = new ArrayList();
+	List types = new ArrayList();
+	for (int a = 0; a < methods.length; ++a)
+	  {
+	    String name = methods[a].getName();
+	    if (name.startsWith("get"))
+	      {
+		names.add(name.substring(3));
+		types.add(getTypeFromClass(methods[a].getReturnType()));
+	      }
+	  }
+	String[] fields = (String[]) names.toArray();
+	CompositeType ctype = new CompositeType(c.getName(), c.getName(),
+						fields, fields,
+						(OpenType[]) types.toArray());
+	return new OpenMBeanParameterInfoSupport("TransParam",
+						 "Translated parameter",
+						 ctype);
+      }
+    catch (NoSuchMethodException e)
+      {
+	/* Ignored; we expect this if this isn't a from(CompositeData) class */
+      }
+    if (c.isArray())
+      {
+	int depth;
+	for (depth = 0; c.getName().charAt(depth) == '['; ++depth);
+	OpenType ot = getTypeFromClass(c.getComponentType());
+	return new OpenMBeanParameterInfoSupport("TransParam",
+						 "Translated parameter",
+						 new ArrayType(depth, ot)
+						 );
+      }
+    throw new InternalError("The type used does not have an open type translation.");
+  }
+
 }
diff --git a/libjava/classpath/gnu/java/lang/management/MemoryMXBeanImpl.java b/libjava/classpath/gnu/java/lang/management/MemoryMXBeanImpl.java
index 064e19a1970..8cb10420213 100644
--- a/libjava/classpath/gnu/java/lang/management/MemoryMXBeanImpl.java
+++ b/libjava/classpath/gnu/java/lang/management/MemoryMXBeanImpl.java
@@ -37,6 +37,8 @@ exception statement from your version. */
 
 package gnu.java.lang.management;
 
+import gnu.classpath.ListenerData;
+
 import java.lang.management.MemoryMXBean;
 import java.lang.management.MemoryNotificationInfo;
 import java.lang.management.MemoryUsage;
@@ -168,49 +170,6 @@ public final class MemoryMXBeanImpl
     VMMemoryMXBeanImpl.setVerbose(verbose);
   }
 
-  private class ListenerData
-  {
-    private NotificationListener listener;
-    private NotificationFilter filter;
-    private Object passback;
-
-    public ListenerData(NotificationListener listener,
-			NotificationFilter filter, Object passback)
-    {
-      this.listener = listener;
-      this.filter = filter;
-      this.passback = passback;
-    }
-    
-    public NotificationListener getListener()
-    {
-      return listener;
-    }
-
-    public NotificationFilter getFilter()
-    {
-      return filter;
-    }
-
-    public Object getPassback()
-    {
-      return passback;
-    }
-
-    public boolean equals(Object obj)
-    {
-      if (obj instanceof ListenerData)
-	{
-	  ListenerData data = (ListenerData) obj;
-	  return (data.getListener() == listener &&
-		  data.getFilter() == filter &&
-		  data.getPassback() == passback);
-	}
-      return false;
-    }
-
-  }
-
   public void addNotificationListener(NotificationListener listener,
 				      NotificationFilter filter,
 				      Object passback)
diff --git a/libjava/classpath/gnu/java/lang/management/MemoryPoolMXBeanImpl.java b/libjava/classpath/gnu/java/lang/management/MemoryPoolMXBeanImpl.java
index ed4dccd769e..e314ca1648a 100644
--- a/libjava/classpath/gnu/java/lang/management/MemoryPoolMXBeanImpl.java
+++ b/libjava/classpath/gnu/java/lang/management/MemoryPoolMXBeanImpl.java
@@ -40,6 +40,7 @@ package gnu.java.lang.management;
 import gnu.classpath.SystemProperties;
 
 import java.lang.management.MemoryPoolMXBean;
+import java.lang.management.MemoryType;
 import java.lang.management.MemoryUsage;
 
 import javax.management.NotCompliantMBeanException;
@@ -133,9 +134,10 @@ public final class MemoryPoolMXBeanImpl
       return null;
   }
 
-  public String getType()
+  public MemoryType getType()
   {
-    return VMMemoryPoolMXBeanImpl.getType(name);
+    return 
+      MemoryType.valueOf(VMMemoryPoolMXBeanImpl.getType(name));
   }
 
   public MemoryUsage getUsage()
diff --git a/libjava/classpath/gnu/java/lang/reflect/ClassSignatureParser.java b/libjava/classpath/gnu/java/lang/reflect/ClassSignatureParser.java
index 0c9b962921e..31f28385f44 100644
--- a/libjava/classpath/gnu/java/lang/reflect/ClassSignatureParser.java
+++ b/libjava/classpath/gnu/java/lang/reflect/ClassSignatureParser.java
@@ -61,7 +61,7 @@ public class ClassSignatureParser extends GenericSignatureParser
         }
         // SuperclassSignature
         superclassType = readClassTypeSignature();
-        ArrayList interfaces = new ArrayList();
+        ArrayList<Type> interfaces = new ArrayList<Type>();
         while (peekChar() == 'L')
         {
             // SuperinterfaceSignature
diff --git a/libjava/classpath/gnu/java/lang/reflect/GenericSignatureParser.java b/libjava/classpath/gnu/java/lang/reflect/GenericSignatureParser.java
index 399f1bdc46f..06bc9e4ab06 100644
--- a/libjava/classpath/gnu/java/lang/reflect/GenericSignatureParser.java
+++ b/libjava/classpath/gnu/java/lang/reflect/GenericSignatureParser.java
@@ -60,7 +60,6 @@ final class TypeVariableImpl extends TypeImpl implements TypeVariable
         return this;
     }
 
-    /* FIXME[GENERICS]: Remove cast */
     public Type[] getBounds()
     {
         resolve(bounds);
@@ -141,10 +140,9 @@ final class ParameterizedTypeImpl extends TypeImpl implements ParameterizedType
         return this;
     }
 
-    /* FIXME[GENERICS]: Remove cast */
     public Type[] getActualTypeArguments()
     {
-        return (Type[]) typeArgs.clone();
+      return (Type[]) typeArgs.clone();
     }
 
     public Type getRawType()
@@ -276,12 +274,11 @@ final class UnresolvedTypeVariable extends TypeImpl implements Type
         GenericDeclaration d = decl;
         while (d != null)
         {
-	    TypeVariable[] vars = d.getTypeParameters();
-            for (int a = 0; a < vars.length  ; ++a)
+            for (TypeVariable t : d.getTypeParameters())
             {
-                if (vars[a].getName().equals(name))
+                if (t.getName().equals(name))
                 {
-                    return vars[a];
+                    return t;
                 }
             }
             d = getParent(d);
@@ -414,7 +411,7 @@ class GenericSignatureParser
     TypeVariable[] readFormalTypeParameters()
     {
         consume('<');
-        ArrayList params = new ArrayList();
+        ArrayList<TypeVariable> params = new ArrayList<TypeVariable>();
         do
         {
             // TODO should we handle name clashes?
@@ -430,7 +427,7 @@ class GenericSignatureParser
     {
         String identifier = readIdentifier();
         consume(':');
-        ArrayList bounds = new ArrayList();
+        ArrayList<Type> bounds = new ArrayList<Type>();
         if (peekChar() != ':')
         {
             bounds.add(readFieldTypeSignature());
@@ -501,7 +498,7 @@ class GenericSignatureParser
     private Type[] readTypeArguments()
     {
         consume('<');
-        ArrayList list = new ArrayList();
+        ArrayList<Type> list = new ArrayList<Type>();
         do
         {
             list.add(readTypeArgument());
diff --git a/libjava/classpath/gnu/java/lang/reflect/MethodSignatureParser.java b/libjava/classpath/gnu/java/lang/reflect/MethodSignatureParser.java
index 16b1af99b73..50f98e29965 100644
--- a/libjava/classpath/gnu/java/lang/reflect/MethodSignatureParser.java
+++ b/libjava/classpath/gnu/java/lang/reflect/MethodSignatureParser.java
@@ -72,7 +72,7 @@ public class MethodSignatureParser extends GenericSignatureParser
             typeParameters = new TypeVariable[0];
         }
         consume('(');
-        ArrayList args = new ArrayList();
+        ArrayList<Type> args = new ArrayList<Type>();
         while (peekChar() != ')')
         {
             args.add(readTypeSignature());
@@ -81,7 +81,7 @@ public class MethodSignatureParser extends GenericSignatureParser
         args.toArray(argTypes);
         consume(')');
         retType = readTypeSignature();
-        ArrayList throwsSigs = new ArrayList();
+        ArrayList<Type> throwsSigs = new ArrayList<Type>();
         while (peekChar() == '^')
         {
             consume('^');