A proper implementation for getGenericParameterTypes using the class ParameterizedTyp...

[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 66b564e1ca4b44979900cb592ab7a81e7d657cbe..efb46e8ec1fdf8415ac5a48e4c01f5cb563095da 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
@@ -86,7 +86,7 @@ public class JPF_java_lang_reflect_Method extends NativePeer {
     MethodInfo mi = getMethodInfo(env, objRef);
     return mi.getModifiers();
   }
-  
+
   static int getParameterTypes( MJIEnv env, MethodInfo mi) {
     ThreadInfo ti = env.getThreadInfo();
     String[] argTypeNames = mi.getArgumentTypeNames();
@@ -108,12 +108,107 @@ public class JPF_java_lang_reflect_Method extends NativePeer {
 
     return aRef;
   }
-  
+
   @MJI
   public int getParameterTypes_____3Ljava_lang_Class_2 (MJIEnv env, int objRef){
     return getParameterTypes(env, getMethodInfo(env, objRef));
   }
-  
+
+  // TODO: Fix for Groovy's model-checking
+  private static int getParameterizedTypeImplObj(String signature, MJIEnv env) {
+
+    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
+    String className = Types.getGenericClassName(signature);
+    ClassInfo gci = cli.getResolvedClassInfo(className);
+    if (!gci.isRegistered()) {
+        gci.registerClass(ti);
+    }
+    ei.setReferenceField("rawType", gci.getClassObjectRef());
+
+    // actualTypeArguments
+    String[] parameterizedTypes = Types.getParameterizedTypesFromArgumentTypeNames(signature);
+    int[] types = new int[parameterizedTypes.length];
+    for(int j = 0; j < parameterizedTypes.length; j++) {
+      ClassInfo pci = cli.getResolvedClassInfo(parameterizedTypes[j]);
+      if (!pci.isRegistered()) {
+        pci.registerClass(ti);
+      }
+      types[j] = pci.getClassObjectRef();
+    }
+    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
+    String ownerType = Types.getOwnerClassName(signature);
+    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;
+  }
+
+  static int getGenericParameterTypes( MJIEnv env, int objRef, MethodInfo mi) {
+    ThreadInfo ti = env.getThreadInfo();
+    String[] argTypeNames = mi.getArgumentGenericTypeNames();
+    int[] ar = new int[argTypeNames.length];
+
+    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);
+      } else {
+        ClassInfo ci = ClassLoaderInfo.getCurrentResolvedClassInfo(argTypeNames[i]);
+        if (!ci.isRegistered()) {
+          ci.registerClass(ti);
+        }
+        ar[i] = ci.getClassObjectRef();
+      }
+    }
+    int aRef = env.newObjectArray("Ljava/lang/reflect/Type;", argTypeNames.length);
+    for (int i = 0; i < argTypeNames.length; i++) {
+      env.setReferenceArrayElement(aRef, i, ar[i]);
+    }
+
+    return aRef;
+  }
+
+  @MJI
+  public int getGenericParameterTypes_____3Ljava_lang_reflect_Type_2 (MJIEnv env, int objRef){
+    return getGenericParameterTypes(env, objRef, getMethodInfo(env, objRef));
+  }
+
+  @MJI
+  public int getGenericReturnType____Ljava_lang_reflect_Type_2 (MJIEnv env, int objRef){
+    MethodInfo mi = getMethodInfo(env, objRef);
+    ThreadInfo ti = env.getThreadInfo();
+
+    ClassInfo ci = ClassLoaderInfo.getCurrentResolvedClassInfo(mi.getReturnTypeName());
+    if (!ci.isRegistered()) {
+      ci.registerClass(ti);
+    }
+
+    return ci.getClassObjectRef();
+  }
+  // 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();
     String[] exceptionNames = mi.getThrownExceptionClassNames();
@@ -146,6 +241,27 @@ public class JPF_java_lang_reflect_Method extends NativePeer {
     return getExceptionTypes(env, getMethodInfo(env, objRef));
   }
   
+  @MJI
+  public int getDefaultValue____Ljava_lang_Object_2(MJIEnv env, int objRef) {
+    MethodInfo mi = getMethodInfo(env, objRef);
+    ClassInfo ci = mi.getClassInfo();
+    if(!ci.isInterface() || ci.getDirectInterfaceNames() == null || ci.getDirectInterfaceNames().length != 1 || !ci.getDirectInterfaceNames()[0].equals("java.lang.annotation.Annotation")) {
+      return MJIEnv.NULL;
+    }
+    String annotationName = ci.getName();
+    AnnotationInfo ai = ci.getClassLoaderInfo().getResolvedAnnotationInfo(annotationName);
+    Object o = ai.getValue(mi.getName());
+    if(o == null) {
+      return MJIEnv.NULL;
+    }
+    try {
+      return env.liftNativeAnnotationValue(Types.getTypeName(mi.getReturnType()), o);
+    } catch(ClinitRequired e) {
+      env.handleClinitRequest(e.getRequiredClassInfo());
+      return -1;
+    }
+  }
+  
   @MJI
   public int getReturnType____Ljava_lang_Class_2 (MJIEnv env, int objRef){
     MethodInfo mi = getMethodInfo(env, objRef);