Adding ParameterizedTypeImpl to getGenericSuperclass method.

diff --git a/examples/Reflection.java b/examples/Reflection.java
index 538bcd1dc3aa54f1ac3c8ab453bf0ae2c816fb29..d8f6e44a742d498236b5627405e938167caab8cc 100644 (file)
--- a/examples/Reflection.java
+++ b/examples/Reflection.java
@@ -12,7 +12,7 @@ public class Reflection {
        class GenericShort<TUVW,ABCD> {
        }
 
-       class Generic<TUVW,ABCD,KLM,NOP> {
+       class Generic<TUVW,ABCD,KLM,NOP> extends GenericShort<TUVW,ABCD> {
        
        }
 
@@ -42,7 +42,7 @@ public class Reflection {
 
    public static void main(String[] args) {
 
-      Method[] methods = SampleClass.class.getMethods();
+      /*Method[] methods = SampleClass.class.getMethods();
       //  Method[] methods = Class.class.getMethods();
         Method method = null;
         for(Method meth : methods) {
@@ -55,7 +55,10 @@ public class Reflection {
       for (int i = 0; i < parameters.length; i++) {
          System.out.println(parameters[i]);
       }
-      System.out.println();
+      System.out.println();*/
+      Type superCls = Generic.class.getGenericSuperclass();
+      //Type superCls = String.class.getGenericSuperclass();
+      System.out.println(superCls);
       /*Class[] parameterTypes = methods[0].getParameterTypes();
       for(Class parameterType: parameterTypes){
          System.out.println(parameterType.getName());   

diff --git a/src/main/gov/nasa/jpf/vm/Types.java b/src/main/gov/nasa/jpf/vm/Types.java
index 6c34925215c48ec78cadfdd7a159c5f6dc0d94ce..90e7f54dca5a3a8ba6316ee3d83a07e9daf4d07a 100644 (file)
--- a/src/main/gov/nasa/jpf/vm/Types.java
+++ b/src/main/gov/nasa/jpf/vm/Types.java
@@ -1248,6 +1248,8 @@ public class Types {
   }
 
   public static boolean isGenericSignature(String signature) {
+    if (signature == null || signature.equals(""))
+      return false;
     int opening = signature.indexOf('<');
     return (opening != -1);
   }

diff --git a/src/peers/gov/nasa/jpf/vm/JPF_java_lang_Class.java b/src/peers/gov/nasa/jpf/vm/JPF_java_lang_Class.java
index ccc98155190d4016c3e1ed2574b4ae958e61d597..cdc5dd709359a91bf10779a84a2ec15e84d7343b 100644 (file)
--- a/src/peers/gov/nasa/jpf/vm/JPF_java_lang_Class.java
+++ b/src/peers/gov/nasa/jpf/vm/JPF_java_lang_Class.java
@@ -108,13 +108,75 @@ public class JPF_java_lang_Class extends NativePeer {
   }
 
   // TODO: Fix for Groovy's model-checking
+  private static int getParameterizedTypeImplObj(String className, String[] parameterizedTypes, String ownerType,
+                                                 MJIEnv env, int objRef, int superObjRef) {
+
+    ThreadInfo ti = env.getThreadInfo();
+    ClassLoaderInfo cli = env.getSystemClassLoaderInfo();
+    ClassInfo ci = cli.getResolvedClassInfo("sun.reflect.generics.reflectiveObjects.ParameterizedTypeImpl");
+    // Create a new object of type ParameterizedTypeImpl
+    int paramTypeRef = env.newObject(ci);
+    ElementInfo ei = env.getModifiableElementInfo(paramTypeRef);
+    // Get field information and fill out the fields
+    // rawType field
+    ei.setReferenceField("rawType", superObjRef);
+
+    // actualTypeArguments
+    int[] types = new int[parameterizedTypes.length];
+    for(int j = 0; j < parameterizedTypes.length; j++) {
+        types[j] = getTypeVariableImplObject(env, objRef, parameterizedTypes[j]);
+    }
+    int aRef = env.newObjectArray("Ljava/lang/reflect/Type;", parameterizedTypes.length);
+    // Set references for every array element
+    for (int j = 0; j < parameterizedTypes.length; j++) {
+      env.setReferenceArrayElement(aRef, j, types[j]);
+    }
+    ei.setReferenceField("actualTypeArguments", aRef);
+
+    // ownerType
+    if (ownerType != null) {
+      ClassInfo oci = ClassLoaderInfo.getCurrentResolvedClassInfo(ownerType);
+      if (!oci.isRegistered()) {
+        oci.registerClass(ti);
+      }
+      ei.setReferenceField("ownerType", oci.getClassObjectRef());
+    } else {
+      ei.setReferenceField("ownerType", MJIEnv.NULL);
+    }
+
+    return paramTypeRef;
+  }
+
+  private static int getTypeVariableImplObject(MJIEnv env, int objRef, String parameterizedType) {
+
+    ClassLoaderInfo cli = env.getSystemClassLoaderInfo();
+    ClassInfo ci = cli.getResolvedClassInfo("sun.reflect.generics.reflectiveObjects.TypeVariableImpl");
+
+    int typeVarRef = env.newObject(ci);
+    ElementInfo ei = env.getModifiableElementInfo(typeVarRef);
+    // genericDeclaration contains this java.lang.reflect.Method object
+    ei.setReferenceField("genericDeclaration", objRef);
+    ei.setReferenceField("name", env.newString(parameterizedType));
+
+    return typeVarRef;
+  }
+
   @MJI
   public int getGenericSuperclass____Ljava_lang_reflect_Type_2 (MJIEnv env, int robj){
-    // TODO: Need to add ParameterizedTypeImpl
     ClassInfo ci = env.getReferredClassInfo( robj);
     ClassInfo sci = ci.getSuperClass();
     if (sci != null) {
-      return sci.getClassObjectRef();
+      String[] typeVars = sci.getGenericTypeVariableNames();
+      // Not a generic class
+      if (typeVars.length == 0) {
+        return sci.getClassObjectRef();
+      }
+      String className = sci.getName();
+      String ownerType = Types.getOwnerClassName(className);
+      int gRef = getParameterizedTypeImplObj(className, typeVars, ownerType, env, ci.getClassObjectRef(),
+              sci.getClassObjectRef());
+
+      return gRef;
     } else {
       return MJIEnv.NULL;
     }

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 48aff581d0190cdbb6152425a8013b8fb2252d1d..fa6ceee3b57261c7eace92feeb699229f9bdbe17 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
@@ -141,7 +141,7 @@ public class JPF_java_lang_reflect_Method extends NativePeer {
     for(int j = 0; j < parameterizedTypes.length; j++) {
       if (Types.isTypeParameter(parameterizedTypes[j], methodGenericSig) ||
           Types.isTypeParameter(parameterizedTypes[j], classGenericSig)) {
-        types[j] = getTypeVariableImplObject(env, objRef, mi, parameterizedTypes[j]);
+        types[j] = getTypeVariableImplObject(env, objRef, parameterizedTypes[j]);
       } else {
         ClassInfo pci = cli.getResolvedClassInfo(parameterizedTypes[j]);
         if (!pci.isRegistered()) {
@@ -172,7 +172,7 @@ public class JPF_java_lang_reflect_Method extends NativePeer {
     return paramTypeRef;
   }
 
-  private static int getTypeVariableImplObject(MJIEnv env, int objRef, MethodInfo mi, String parameterizedType) {
+  private static int getTypeVariableImplObject(MJIEnv env, int objRef, String parameterizedType) {
 
     ClassLoaderInfo cli = env.getSystemClassLoaderInfo();
     ClassInfo ci = cli.getResolvedClassInfo("sun.reflect.generics.reflectiveObjects.TypeVariableImpl");