From bed8787d5d6a88ee4b8656b9bcee644319f8a8c0 Mon Sep 17 00:00:00 2001 From: rtrimana Date: Mon, 24 Jun 2019 15:21:54 -0700 Subject: [PATCH] Fixing the method getGenericParameterTypes to recognize the GenericArrayTypeImpl type. --- examples/Reflection.java | 13 +++++----- .../GenericArrayTypeImpl.java | 15 ----------- src/main/gov/nasa/jpf/vm/Types.java | 18 ++++++++++++- .../jpf/vm/JPF_java_lang_reflect_Method.java | 25 ++++++++++++++++++- 4 files changed, 48 insertions(+), 23 deletions(-) diff --git a/examples/Reflection.java b/examples/Reflection.java index f446b4b..e1ea00c 100644 --- 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 d9ba178..1d8063b 100644 --- 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 Type object representing the component type - * of this array. - * - * @return a Type 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 c29cb1d..64aec5c 100644 --- 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 4aa670d..299fb61 100644 --- 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()) { -- 2.34.1