Fixing the method getGenericParameterTypes to recognize the GenericArrayTypeImpl...

diff --git a/examples/Reflection.java b/examples/Reflection.java
index f446b4bf4644f9e8d27c36b618a11d6504ff28eb..e1ea00c96605b21f2fb228f0d2767d9c594511cd 100644 (file)
--- a/examples/Reflection.java
+++ b/examples/Reflection.java
@@ -73,13 +73,14 @@ public class Reflection {
             System.out.println(interfaces[i]);
         }*/
       
-      Method[] methods = SampleClass.class.getMethods();
-        Method method = null;
-        for(Method mth : methods) {
-            if (mth.getName().equals("setSampleField")) {
-                method = mth;
-            }
+         Method[] methods = Class.class.getMethods();
+         Method method = null;
+      for(Method mth : methods) {
+        //if (mth.getName().equals("getConstructor")) {
+        if (mth.getName().equals("isAssignableFrom")) {
+           method = mth;
         }
+      }
       Type[] parameters = method.getGenericParameterTypes();
       //Type[] parameters = methods[0].getGenericParameterTypes();
       for (int i = 0; i < parameters.length; i++) {

diff --git a/src/classes/sun/reflect/generics/reflectiveObjects/GenericArrayTypeImpl.java b/src/classes/sun/reflect/generics/reflectiveObjects/GenericArrayTypeImpl.java
index d9ba1788fc791268b940e7adfadf05e8ff6d0f49..1d8063b753cae5740af22f7f6ba9b584768a2ab6 100644 (file)
--- a/src/classes/sun/reflect/generics/reflectiveObjects/GenericArrayTypeImpl.java
+++ b/src/classes/sun/reflect/generics/reflectiveObjects/GenericArrayTypeImpl.java
@@ -25,25 +25,10 @@ public class GenericArrayTypeImpl
         genericComponentType = ct;
     }
 
-    /**
-     * Factory method.
-     * @param ct - the desired component type of the generic array type
-     * being created
-     * @return a generic array type with the desired component type
-     */
     public static GenericArrayTypeImpl make(Type ct) {
         return new GenericArrayTypeImpl(ct);
     }
 
-
-    /**
-     * Returns  a <tt>Type</tt> object representing the component type
-     * of this array.
-     *
-     * @return  a <tt>Type</tt> object representing the component type
-     *     of this array
-     * @since 1.5
-     */
     public Type getGenericComponentType() {
         return genericComponentType; // return cached component type
     }

diff --git a/src/main/gov/nasa/jpf/vm/Types.java b/src/main/gov/nasa/jpf/vm/Types.java
index c29cb1da08e4b9aef044a550418c850e4048db33..64aec5c886a94f994534b3f94812e3246e1bf165 100644 (file)
--- a/src/main/gov/nasa/jpf/vm/Types.java
+++ b/src/main/gov/nasa/jpf/vm/Types.java
@@ -1113,7 +1113,8 @@ public class Types {
       int genericStart = currParam.indexOf('<');
       if (genericStart != -1) {
         if (currParam.charAt(genericStart + 1) == '*') {
-          semicolon = genericStart + 4;
+          // Need to offset with idx to anticipate for array types (idx is incremented for array types)
+          semicolon = genericStart + idx + 3;
         } else {
           int generic = signature.indexOf('>', semicolon);
           if (generic != -1) {
@@ -1245,6 +1246,14 @@ public class Types {
       return signature.substring(0, opening);
   }
 
+  public static String getArrayClassName(String signature) {
+    int opening = signature.indexOf('[');
+    if (opening == -1)
+      return signature;
+    else
+      return signature.substring(0, opening);
+  }
+
   public static String getOwnerClassName(String signature) {
     int marker = signature.indexOf('$');
     if (marker == -1)
@@ -1260,6 +1269,13 @@ public class Types {
     return (opening != -1);
   }
 
+  public static boolean isArraySignature(String signature) {
+    if (signature == null || signature.equals(""))
+      return false;
+    int opening = signature.indexOf('[');
+    return (opening != -1);
+  }
+
   public static boolean isTypeParameter(String parameterizedType, String signature) {
     if (signature == null || signature.equals(""))
       return false;

diff --git a/src/peers/gov/nasa/jpf/vm/JPF_java_lang_reflect_Method.java b/src/peers/gov/nasa/jpf/vm/JPF_java_lang_reflect_Method.java
index 4aa670d5d37a8f25f8b680ea7df29bc2aeffdfc7..299fb619fe13f7e8286ff9bc6e89ce2d86b0136e 100644 (file)
--- a/src/peers/gov/nasa/jpf/vm/JPF_java_lang_reflect_Method.java
+++ b/src/peers/gov/nasa/jpf/vm/JPF_java_lang_reflect_Method.java
@@ -116,6 +116,24 @@ public class JPF_java_lang_reflect_Method extends NativePeer {
   }
 
   // TODO: Fix for Groovy's model-checking
+  private static int getGenericArrayTypeImplObj(String signature, MJIEnv env, int objRef, MethodInfo mi) {
+
+    ThreadInfo ti = env.getThreadInfo();
+    ClassLoaderInfo cli = env.getSystemClassLoaderInfo();
+    ClassInfo ci = cli.getResolvedClassInfo("sun.reflect.generics.reflectiveObjects.GenericArrayTypeImpl");
+
+    // Create a new object of type GenericArrayTypeImpl
+    int genArrRef = env.newObject(ci);
+    ElementInfo ei = env.getModifiableElementInfo(genArrRef);
+
+    // Get field information and fill out the fields
+    String clsSig = Types.getArrayClassName(signature);
+    int paramTypeRef = getParameterizedTypeImplObj(clsSig, env, objRef, mi);
+    ei.setReferenceField("genericComponentType", paramTypeRef);
+
+    return genArrRef;
+  }
+
   private static int getParameterizedTypeImplObj(String signature, MJIEnv env, int objRef, MethodInfo mi) {
 
     ThreadInfo ti = env.getThreadInfo();
@@ -226,7 +244,12 @@ public class JPF_java_lang_reflect_Method extends NativePeer {
     for (int i = 0; i < argTypeNames.length; i++) {
       // Change this into just the generic class type if it is a generic class
       if (Types.isGenericSignature(argTypeNames[i])) {
-        ar[i] = getParameterizedTypeImplObj(argTypeNames[i], env, objRef, mi);
+        if (Types.isArraySignature(argTypeNames[i])) {
+          // Generic array
+          ar[i] = getGenericArrayTypeImplObj(argTypeNames[i], env, objRef, mi);
+        } else {
+          ar[i] = getParameterizedTypeImplObj(argTypeNames[i], env, objRef, mi);
+        }
       } else {
         ClassInfo ci = ClassLoaderInfo.getCurrentResolvedClassInfo(argTypeNames[i]);
         if (!ci.isRegistered()) {