Finalizing the beta version of the implementation for Groovy extension in JPF: JPF...

[jpf-core.git] / src / peers / gov / nasa / jpf / vm / JPF_java_lang_reflect_Method.java

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..3baa1651b31a3fdbdaa777a8fa0e16d723e9f10a 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();
@@ -141,7 +159,12 @@ 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 if (Types.isWildcardType(parameterizedTypes[j])) {
+        types[j] = getWildcardTypeImplObject(env, objRef, parameterizedTypes[j], mi);
+      } else if (Types.isParameterizedType(parameterizedTypes[j])) {
+        // Recursion!
+        types[j] = getParameterizedTypeImplObj(parameterizedTypes[j], env, objRef, mi);
       } else {
         ClassInfo pci = cli.getResolvedClassInfo(parameterizedTypes[j]);
         if (!pci.isRegistered()) {
@@ -172,7 +195,59 @@ 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 getWildcardTypeImplObject(MJIEnv env, int objRef, String wildcardType, MethodInfo mi) {
+    ThreadInfo ti = env.getThreadInfo();
+    ClassLoaderInfo cli = env.getSystemClassLoaderInfo();
+    ClassInfo ci = cli.getResolvedClassInfo("sun.reflect.generics.reflectiveObjects.WildcardTypeImpl");
+
+    int wildcardRef = env.newObject(ci);
+    ElementInfo ei = env.getModifiableElementInfo(wildcardRef);
+    // Type parameter test
+    // TODO: This test could probably be made cleaner
+    String classGenericSig = mi.getClassInfo().getGenericSignature();
+    String methodGenericSig = mi.getGenericSignature();
+    String typeParameter = Types.getTypeParameter(wildcardType);
+    int uRef = MJIEnv.NULL;
+    int lRef = MJIEnv.NULL;
+    if (Types.isTypeParameter(typeParameter, methodGenericSig) ||
+        Types.isTypeParameter(typeParameter, classGenericSig)) {
+      int tpRef = getTypeVariableImplObject(env, objRef, typeParameter);
+      if (wildcardType.startsWith("+")) {
+        // Set upperBounds
+        uRef = env.newObjectArray("Ljava/lang/reflect/Type;", 1);
+        env.setReferenceArrayElement(uRef, 0, tpRef);
+        lRef = env.newObjectArray("Ljava/lang/reflect/Type;", 0);
+      } else { // wildcardType.startsWith("-")
+        // Set lowerBounds
+        lRef = env.newObjectArray("Ljava/lang/reflect/Type;", 1);
+        env.setReferenceArrayElement(lRef, 0, tpRef);
+        uRef = env.newObjectArray("Ljava/lang/reflect/Type;", 0);
+      }
+    } else {
+
+      String actualType = Types.getWildcardType(wildcardType);
+      ClassInfo uci = cli.getResolvedClassInfo(actualType);
+      if (!uci.isRegistered()) {
+        uci.registerClass(ti);
+      }
+      if (wildcardType.startsWith("+L") || wildcardType.equals("*")) {
+        // Set upperBounds
+        uRef = env.newObjectArray("Ljava/lang/reflect/Type;", 1);
+        env.setReferenceArrayElement(uRef, 0, uci.getClassObjectRef());
+        lRef = env.newObjectArray("Ljava/lang/reflect/Type;", 0);
+      } else { // wildcardType.startsWith("-L")
+        // Set lowerBounds
+        lRef = env.newObjectArray("Ljava/lang/reflect/Type;", 1);
+        env.setReferenceArrayElement(lRef, 0, uci.getClassObjectRef());
+      }
+    }
+    ei.setReferenceField("upperBounds", uRef);
+    ei.setReferenceField("lowerBounds", lRef);
+
+    return wildcardRef;
+  }
+
+  private static int getTypeVariableImplObject(MJIEnv env, int objRef, String parameterizedType) {
 
     ClassLoaderInfo cli = env.getSystemClassLoaderInfo();
     ClassInfo ci = cli.getResolvedClassInfo("sun.reflect.generics.reflectiveObjects.TypeVariableImpl");
@@ -194,7 +269,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()) {
@@ -207,7 +287,6 @@ public class JPF_java_lang_reflect_Method extends NativePeer {
     for (int i = 0; i < argTypeNames.length; i++) {
       env.setReferenceArrayElement(aRef, i, ar[i]);
     }
-
     return aRef;
   }
 
@@ -223,7 +302,12 @@ public class JPF_java_lang_reflect_Method extends NativePeer {
 
     int retRef;
     if (Types.isGenericSignature(mi.getGenericReturnTypeName())) {
-      retRef = getParameterizedTypeImplObj(mi.getGenericReturnTypeName(), env, objRef, mi);
+      if (Types.isArraySignature(mi.getGenericReturnTypeName())) {
+        // Generic array
+        retRef = getGenericArrayTypeImplObj(mi.getGenericReturnTypeName(), env, objRef, mi);
+      } else {
+        retRef = getParameterizedTypeImplObj(mi.getGenericReturnTypeName(), env, objRef, mi);
+      }
     } else {
       ClassInfo ci = ClassLoaderInfo.getCurrentResolvedClassInfo(mi.getReturnTypeName());
       if (!ci.isRegistered()) {
@@ -235,7 +319,6 @@ public class JPF_java_lang_reflect_Method extends NativePeer {
     return retRef;
   }
   // TODO: Fix for Groovy's model-checking
-  // TODO: We have been able to only register the generic class and not yet the parameterized types
 
   int getExceptionTypes(MJIEnv env, MethodInfo mi) {
     ThreadInfo ti = env.getThreadInfo();