feat: mutator support for generic superclasses

This commit adds mutator support for classes that have generic
superclasses. The inheritance chain is walked up collecting all type
parameters. This is also done for all interfaces.

Author: simonresch

src/main/java/com/code_intelligence/jazzer/mutation/mutator/aggregate/BeanSupport.java

@@ -32,6 +32,7 @@
 import java.lang.reflect.Executable;
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
+import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;
 import java.util.Arrays;
 import java.util.Comparator;
@@ -52,17 +53,27 @@ static Optional<Class<?>> optionalClassForName(String targetClassName) {
     }
   }
 
+  private static Class<?> rawBeanType(Type classType) {
+    if (classType instanceof Class<?>) {
+      return (Class<?>) classType;
+    } else if (classType instanceof ParameterizedType) {
+      return rawBeanType(((ParameterizedType) classType).getRawType());
+    } else {
+      // Bail out on wildcard types or type variables neither of which are supported as "top level"
+      // types in a @FuzzTest. Also bail out on generic array types as they are handled by the
+      // ArrayMutatorFactory.
+      throw new UnsupportedOperationException("Unsupported type: " + classType);
+    }
+  }
+
   // Returns the annotated parameter types of a method or constructor resolving all generic type
   // arguments.
   public static AnnotatedType[] resolveAnnotatedParameterTypes(
       Executable e, AnnotatedType classType) {
-    Type[] generic = e.getGenericParameterTypes();
-    AnnotatedType[] annotated = e.getAnnotatedParameterTypes();
-    AnnotatedType[] result = new AnnotatedType[generic.length];
-    for (int i = 0; i < generic.length; i++) {
-      result[i] = resolveTypeArguments(e.getDeclaringClass(), classType, annotated[i]);
-    }
-    return result;
+    Class<?> clazz = rawBeanType(classType.getType());
+    return stream(e.getAnnotatedParameterTypes())
+        .map(t -> resolveTypeArguments(clazz, classType, t))
+        .toArray(AnnotatedType[]::new);
   }
 
   // Returns the parameter types of a method or constructor resolving all generic type arguments.
@@ -74,7 +85,7 @@ public static Type[] resolveParameterTypes(Executable e, AnnotatedType classType
 
   static Type resolveReturnType(Method method, AnnotatedType classType) {
     return resolveTypeArguments(
-            method.getDeclaringClass(), classType, method.getAnnotatedReturnType())
+            rawBeanType(classType.getType()), classType, method.getAnnotatedReturnType())
         .getType();
   }
 

src/main/java/com/code_intelligence/jazzer/mutation/support/ParameterizedTypeSupport.java

@@ -64,21 +64,50 @@ public class ParameterizedTypeSupport {
    */
   public static AnnotatedType resolveTypeArguments(
       Class<?> clazz, AnnotatedType classType, AnnotatedType type) {
-    if (!(classType instanceof AnnotatedParameterizedType)) {
+    Map<TypeVariable<?>, AnnotatedType> mapping = new HashMap<>();
+    updateTypeMappings(clazz, classType, mapping);
+    if (mapping.isEmpty()) {
       return type;
     }
+    return resolveRecursive(type.getType(), type, mapping);
+  }
 
-    TypeVariable<?>[] typeParameters = clazz.getTypeParameters();
-    AnnotatedType[] typeArguments =
-        ((AnnotatedParameterizedType) classType).getAnnotatedActualTypeArguments();
+  private static void updateTypeMappings(
+      Class<?> clazz,
+      AnnotatedType annotatedClazzType,
+      Map<TypeVariable<?>, AnnotatedType> mapping) {
+    if (annotatedClazzType instanceof AnnotatedParameterizedType) {
+      TypeVariable<?>[] typeParameters = clazz.getTypeParameters();
+      AnnotatedType[] typeArguments =
+          ((AnnotatedParameterizedType) annotatedClazzType).getAnnotatedActualTypeArguments();
+      require(typeArguments.length == typeParameters.length);
+      for (int i = 0; i < typeParameters.length; i++) {
+        mapping.put(typeParameters[i], typeArguments[i]);
+      }
+    }
 
-    require(typeArguments.length == typeParameters.length);
+    Class<?> superClass = clazz.getSuperclass();
+    AnnotatedType annotatedSuperclass = clazz.getAnnotatedSuperclass();
+    Type genericSuperclass = clazz.getGenericSuperclass();
+    if (superClass != null && annotatedSuperclass != null && genericSuperclass != null) {
+      AnnotatedType resolvedSuperclass =
+          resolveRecursive(genericSuperclass, annotatedSuperclass, mapping);
+      updateTypeMappings(superClass, resolvedSuperclass, mapping);
+    }
 
-    Map<TypeVariable<?>, AnnotatedType> mapping = new HashMap<>();
-    for (int i = 0; i < typeParameters.length; i++) {
-      mapping.put(typeParameters[i], typeArguments[i]);
+    Class<?>[] interfaces = clazz.getInterfaces();
+    AnnotatedType[] annotatedInterfaces = clazz.getAnnotatedInterfaces();
+    Type[] genericInterfaces = clazz.getGenericInterfaces();
+    for (int i = 0; i < interfaces.length; i++) {
+      AnnotatedType annotatedInterface = annotatedInterfaces[i];
+      Type genericInterface = genericInterfaces[i];
+      if (annotatedInterface == null || genericInterface == null) {
+        continue;
+      }
+      AnnotatedType resolvedInterface =
+          resolveRecursive(genericInterface, annotatedInterface, mapping);
+      updateTypeMappings(interfaces[i], resolvedInterface, mapping);
     }
-    return resolveRecursive(type.getType(), type, mapping);
   }
 
   /**
@@ -107,6 +136,10 @@ private static AnnotatedType resolveRecursive(
       if (replacement == null) {
         return annotated;
       }
+      if (replacement instanceof AnnotatedWildcardType) {
+        // Forwarding annotations to wildcard types is not supported
+        return replacement;
+      }
       return TypeSupport.forwardAnnotations(annotated, replacement);
     }
     return annotated;

src/test/java/com/code_intelligence/jazzer/mutation/mutator/aggregate/SetterBasedBeanMutatorTest.java

@@ -246,4 +246,14 @@ void genericClass() {
                 .createOrThrow(new TypeHolder<Generic<String>>() {}.annotatedType());
     assertThat(mutator.toString()).isEqualTo("Nullable<[Nullable<Nullable<String>[]>] -> Generic>");
   }
+
+  public static class Child extends Generic<String> {}
+
+  @Test
+  void genericClassChild() {
+    SerializingMutator<Child> mutator =
+        (SerializingMutator<Child>)
+            Mutators.newFactory().createOrThrow(new TypeHolder<Child>() {}.annotatedType());
+    assertThat(mutator.toString()).isEqualTo("Nullable<[Nullable<Nullable<String>[]>] -> Child>");
+  }
 }

src/test/java/com/code_intelligence/jazzer/mutation/support/ParameterizedTypeSupportTest.java

@@ -125,4 +125,89 @@ class Generic<S, T> {
     assertThat(parameterizedType.getActualTypeArguments()[0]).isEqualTo(String.class);
     assertThat(parameterizedType.getActualTypeArguments()[1]).isEqualTo(Integer.class);
   }
+
+  @Test
+  void resolveParameterizedTypeChildClass() throws NoSuchFieldException {
+    class Base<T, U> {
+      public Map<T, U> field;
+    }
+    class Child<U> extends Base<String, U> {}
+    AnnotatedType annotatedType = Child.class.getField("field").getAnnotatedType();
+    AnnotatedParameterizedType classType =
+        (AnnotatedParameterizedType) new TypeHolder<Child<Integer>>() {}.annotatedType();
+    AnnotatedType resolved =
+        ParameterizedTypeSupport.resolveTypeArguments(Child.class, classType, annotatedType);
+
+    assertThat(resolved).isInstanceOf(AnnotatedParameterizedType.class);
+
+    AnnotatedParameterizedType parameterType = (AnnotatedParameterizedType) resolved;
+    assertThat(((ParameterizedType) parameterType.getType()).getRawType()).isEqualTo(Map.class);
+    AnnotatedType[] elementTypes = parameterType.getAnnotatedActualTypeArguments();
+    assertThat(elementTypes).hasLength(2);
+    assertThat(elementTypes[0].getType()).isEqualTo(String.class);
+    assertThat(
+            TypeSupport.annotatedTypeEquals(
+                classType.getAnnotatedActualTypeArguments()[0], elementTypes[1]))
+        .isTrue();
+  }
+
+  @Test
+  void resolveParameterizedType_multiLevelHierarchy() throws NoSuchFieldException {
+    class Root<T> {
+      public List<T> field;
+    }
+    class Middle<U> extends Root<List<U>> {}
+    class Leaf<V> extends Middle<V> {}
+    class Concrete extends Leaf<String> {}
+
+    AnnotatedType annotatedType = Concrete.class.getField("field").getAnnotatedType();
+    AnnotatedType classType = new TypeHolder<Concrete>() {}.annotatedType();
+    AnnotatedType resolved =
+        ParameterizedTypeSupport.resolveTypeArguments(Concrete.class, classType, annotatedType);
+
+    assertThat(resolved).isInstanceOf(AnnotatedParameterizedType.class);
+
+    AnnotatedParameterizedType outerList = (AnnotatedParameterizedType) resolved;
+    assertThat(((ParameterizedType) outerList.getType()).getRawType()).isEqualTo(List.class);
+    AnnotatedType nestedListType = outerList.getAnnotatedActualTypeArguments()[0];
+    assertThat(nestedListType).isInstanceOf(AnnotatedParameterizedType.class);
+
+    AnnotatedParameterizedType innerList = (AnnotatedParameterizedType) nestedListType;
+    assertThat(((ParameterizedType) innerList.getType()).getRawType()).isEqualTo(List.class);
+    AnnotatedType innerElement = innerList.getAnnotatedActualTypeArguments()[0];
+    assertThat(innerElement.getType()).isEqualTo(String.class);
+  }
+
+  private interface LocalSupplier<T> {
+    List<T> supply();
+  }
+
+  private interface AnnotatedSupplier<U> extends LocalSupplier<List<U>> {}
+
+  @Test
+  void resolveParameterizedType_interfaceHierarchy() throws NoSuchMethodException {
+    AnnotatedType annotatedType = LocalSupplier.class.getMethod("supply").getAnnotatedReturnType();
+    AnnotatedParameterizedType interfaceType =
+        (AnnotatedParameterizedType)
+            new TypeHolder<AnnotatedSupplier<@NotNull String>>() {}.annotatedType();
+    AnnotatedType resolved =
+        ParameterizedTypeSupport.resolveTypeArguments(
+            AnnotatedSupplier.class, interfaceType, annotatedType);
+
+    assertThat(resolved).isInstanceOf(AnnotatedParameterizedType.class);
+
+    AnnotatedParameterizedType outerList = (AnnotatedParameterizedType) resolved;
+    assertThat(((ParameterizedType) outerList.getType()).getRawType()).isEqualTo(List.class);
+
+    AnnotatedType nestedType = outerList.getAnnotatedActualTypeArguments()[0];
+    assertThat(nestedType).isInstanceOf(AnnotatedParameterizedType.class);
+
+    AnnotatedParameterizedType innerList = (AnnotatedParameterizedType) nestedType;
+    assertThat(((ParameterizedType) innerList.getType()).getRawType()).isEqualTo(List.class);
+    AnnotatedType terminalElement = innerList.getAnnotatedActualTypeArguments()[0];
+    assertThat(
+            TypeSupport.annotatedTypeEquals(
+                interfaceType.getAnnotatedActualTypeArguments()[0], terminalElement))
+        .isTrue();
+  }
 }