feat: support generic constructor based beans

Author: simonresch

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

@@ -18,6 +18,9 @@
 
 import static com.code_intelligence.jazzer.mutation.combinator.MutatorCombinators.mutateThenMap;
 import static com.code_intelligence.jazzer.mutation.combinator.MutatorCombinators.mutateThenMapToImmutable;
+import static com.code_intelligence.jazzer.mutation.mutator.aggregate.BeanSupport.resolveAnnotatedParameterTypes;
+import static com.code_intelligence.jazzer.mutation.mutator.aggregate.BeanSupport.resolveParameterTypes;
+import static com.code_intelligence.jazzer.mutation.mutator.aggregate.BeanSupport.resolveReturnType;
 import static com.code_intelligence.jazzer.mutation.support.PropertyConstraintSupport.propagatePropertyConstraints;
 import static com.code_intelligence.jazzer.mutation.support.ReflectionSupport.unreflectMethod;
 import static com.code_intelligence.jazzer.mutation.support.ReflectionSupport.unreflectMethods;
@@ -60,25 +63,22 @@ static Optional<SerializingMutator<?>> createMutator(
             getters.length, instantiator));
     for (int i = 0; i < getters.length; i++) {
       Preconditions.check(
-          getters[i]
-              .getAnnotatedReturnType()
-              .getType()
-              .equals(instantiator.getAnnotatedParameterTypes()[i].getType()),
+          resolveReturnType(getters[i], initialType)
+              .equals(resolveParameterTypes(instantiator, initialType)[i]),
           String.format(
               "Parameter %d of %s does not match return type of %s", i, instantiator, getters[i]));
     }
 
     // TODO: Ideally, we would have the mutator framework pass in a Lookup for the fuzz test class.
     MethodHandles.Lookup lookup = MethodHandles.lookup();
     return createMutator(
-            factory,
-            instantiator.getDeclaringClass(),
-            instantiator.getAnnotatedParameterTypes(),
-            asInstantiationFunction(lookup, instantiator),
-            makeSingleGetter(unreflectMethods(lookup, getters)),
-            initialType,
-            isImmutable)
-        .map(m -> m);
+        factory,
+        instantiator.getDeclaringClass(),
+        resolveAnnotatedParameterTypes(instantiator, initialType),
+        asInstantiationFunction(lookup, instantiator),
+        makeSingleGetter(unreflectMethods(lookup, getters)),
+        initialType,
+        isImmutable);
   }
 
   static Optional<SerializingMutator<?>> createMutator(
@@ -105,14 +105,13 @@ static Optional<SerializingMutator<?>> createMutator(
     // TODO: Ideally, we would have the mutator framework pass in a Lookup for the fuzz test class.
     MethodHandles.Lookup lookup = MethodHandles.lookup();
     return createMutator(
-            factory,
-            newInstance.getDeclaringClass(),
-            parameterTypes(setters),
-            asInstantiationFunction(lookup, newInstance, setters),
-            makeSingleGetter(unreflectMethods(lookup, getters)),
-            initialType,
-            /* isImmutable= */ false)
-        .map(m -> m);
+        factory,
+        newInstance.getDeclaringClass(),
+        parameterTypes(setters),
+        asInstantiationFunction(lookup, newInstance, setters),
+        makeSingleGetter(unreflectMethods(lookup, getters)),
+        initialType,
+        /* isImmutable= */ false);
   }
 
   @SuppressWarnings("Immutable")

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

@@ -26,10 +26,14 @@
 import static java.util.stream.Collectors.toMap;
 
 import java.beans.Introspector;
+import java.lang.reflect.AnnotatedParameterizedType;
+import java.lang.reflect.AnnotatedType;
 import java.lang.reflect.Constructor;
+import java.lang.reflect.Executable;
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
 import java.lang.reflect.Type;
+import java.lang.reflect.TypeVariable;
 import java.util.Arrays;
 import java.util.Comparator;
 import java.util.HashMap;
@@ -49,6 +53,54 @@ static Optional<Class<?>> optionalClassForName(String targetClassName) {
     }
   }
 
+  // Returns the resolved type argument for a generic class if one exists.
+  // For example: For the class `class MyClass<T> {}` with annotated type `MyClass<String>`,
+  // calling `resolveTypeArgument(MyClass.class, annotatedType, "T")` returns
+  // `Optional.of(String.class)`.
+  private static Optional<AnnotatedType> resolveTypeArgument(
+      Class<?> clazz, AnnotatedType classType, String typeName) {
+    if (classType instanceof AnnotatedParameterizedType) {
+      TypeVariable<?>[] typeParameters = clazz.getTypeParameters();
+      AnnotatedType[] typeArguments =
+          ((AnnotatedParameterizedType) classType).getAnnotatedActualTypeArguments();
+      for (int i = 0; i < typeParameters.length; i++) {
+        if (typeParameters[i].getName().equals(typeName)) {
+          return Optional.of(typeArguments[i]);
+        }
+      }
+    }
+    return Optional.empty();
+  }
+
+  // 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] =
+          resolveTypeArgument(e.getDeclaringClass(), classType, generic[i].getTypeName())
+              .orElse(annotated[i]);
+    }
+    return result;
+  }
+
+  // Returns the parameter types of a method or constructor resolving all generic type arguments.
+  public static Type[] resolveParameterTypes(Executable e, AnnotatedType classType) {
+    return stream(resolveAnnotatedParameterTypes(e, classType))
+        .map(AnnotatedType::getType)
+        .toArray(Type[]::new);
+  }
+
+  static Type resolveReturnType(Method method, AnnotatedType classType) {
+    return resolveTypeArgument(
+            method.getDeclaringClass(), classType, method.getGenericReturnType().getTypeName())
+        .orElse(method.getAnnotatedReturnType())
+        .getType();
+  }
+
   static boolean isConcreteClass(Class<?> clazz) {
     return !Modifier.isAbstract(clazz.getModifiers());
   }
@@ -88,9 +140,11 @@ static Optional<Method[]> findGettersByPropertyNames(
         propertyNames.map(gettersByPropertyName::get).map(Optional::ofNullable), Method[]::new);
   }
 
-  static Optional<Method[]> findGettersByPropertyTypes(Class<?> clazz, Stream<Class<?>> types) {
-    Map<Class<?>, List<Method>> gettersByType =
-        findMethods(clazz, BeanSupport::isGetter).collect(groupingBy(Method::getReturnType));
+  static Optional<Method[]> findGettersByPropertyTypes(
+      Class<?> clazz, AnnotatedType classType, Stream<Type> types) {
+    Map<Type, List<Method>> gettersByType =
+        findMethods(clazz, BeanSupport::isGetter)
+            .collect(groupingBy(m -> resolveReturnType(m, classType)));
     return toArrayOrEmpty(
         types.map(
             type -> {
@@ -122,10 +176,10 @@ private static Optional<String> trimPrefix(String name, String prefix) {
     }
   }
 
-  static boolean matchingReturnTypes(Method[] methods, Type[] types) {
+  static boolean matchingReturnTypes(Method[] methods, AnnotatedType classType, Type[] types) {
     for (int i = 0; i < methods.length; i++) {
       // TODO: Support Optional<T> getters, which often have a corresponding T setter.
-      if (!methods[i].getAnnotatedReturnType().getType().equals(types[i])) {
+      if (!resolveReturnType(methods[i], classType).equals(types[i])) {
         return false;
       }
     }

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

@@ -20,6 +20,8 @@
 import static com.code_intelligence.jazzer.mutation.mutator.aggregate.BeanSupport.findGettersByPropertyNames;
 import static com.code_intelligence.jazzer.mutation.mutator.aggregate.BeanSupport.findGettersByPropertyTypes;
 import static com.code_intelligence.jazzer.mutation.mutator.aggregate.BeanSupport.matchingReturnTypes;
+import static com.code_intelligence.jazzer.mutation.mutator.aggregate.BeanSupport.resolveAnnotatedParameterTypes;
+import static com.code_intelligence.jazzer.mutation.mutator.aggregate.BeanSupport.resolveParameterTypes;
 import static com.code_intelligence.jazzer.mutation.support.StreamSupport.findFirstPresent;
 import static com.code_intelligence.jazzer.mutation.support.TypeSupport.asSubclassOrEmpty;
 import static java.util.Arrays.stream;
@@ -50,11 +52,13 @@ public Optional<SerializingMutator<?>> tryCreate(
                         .filter(constructor -> constructor.getParameterCount() > 0)
                         .map(
                             constructor ->
-                                findParameterGetters(clazz, constructor)
+                                findParameterGetters(clazz, type, constructor)
                                     .filter(
                                         getters ->
                                             matchingReturnTypes(
-                                                getters, constructor.getParameterTypes()))
+                                                getters,
+                                                type,
+                                                resolveParameterTypes(constructor, type)))
                                     .flatMap(
                                         getters -> {
                                           // Try to create mutator based on constructor and getters,
@@ -65,7 +69,8 @@ public Optional<SerializingMutator<?>> tryCreate(
                                         }))));
   }
 
-  private Optional<Method[]> findParameterGetters(Class<?> clazz, Constructor<?> constructor) {
+  private Optional<Method[]> findParameterGetters(
+      Class<?> clazz, AnnotatedType type, Constructor<?> constructor) {
     // Prefer explicit Java Bean ConstructorProperties annotation to determine parameter names.
     ConstructorProperties parameterNames = constructor.getAnnotation(ConstructorProperties.class);
     if (parameterNames != null
@@ -78,7 +83,8 @@ private Optional<Method[]> findParameterGetters(Class<?> clazz, Constructor<?> c
       return findGettersByPropertyNames(clazz, stream(parameters).map(Parameter::getName));
     } else {
       // Last fallback to parameter types.
-      return findGettersByPropertyTypes(clazz, stream(parameters).map(Parameter::getType));
+      return findGettersByPropertyTypes(
+          clazz, type, stream(resolveParameterTypes(constructor, type)));
     }
   }
 }

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

@@ -54,6 +54,7 @@ clazz, stream(setters).map(BeanSupport::toPropertyName))
                       getters ->
                           matchingReturnTypes(
                               getters,
+                              type,
                               stream(setters)
                                   .map(setter -> setter.getAnnotatedParameterTypes()[0].getType())
                                   .toArray(Type[]::new)))

src/test/java/com/code_intelligence/jazzer/mutation/mutator/StressTest.java

@@ -405,6 +405,31 @@ public String toString() {
     }
   }
 
+  public static class GenericConstructorBasedBean<T> {
+    T t;
+
+    GenericConstructorBasedBean(T t) {
+      this.t = t;
+    }
+
+    public T getT() {
+      return t;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (this == o) return true;
+      if (o == null || getClass() != o.getClass()) return false;
+      GenericConstructorBasedBean<T> that = (GenericConstructorBasedBean<T>) o;
+      return Objects.equals(this.t, that.t);
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hash(this.t);
+    }
+  }
+
   public static class OnlyConstructorBean {
     private final String foo;
     private final List<Integer> bar;
@@ -895,6 +920,13 @@ void singleParam(int parameter) {}
             false,
             manyDistinctElements(),
             manyDistinctElements()),
+        arguments(
+            new TypeHolder<
+                @NotNull GenericConstructorBasedBean<@NotNull String>>() {}.annotatedType(),
+            "[String] -> GenericConstructorBasedBean",
+            false,
+            manyDistinctElements(),
+            manyDistinctElements()),
         arguments(
             new TypeHolder<@NotNull OnlyConstructorBean>() {}.annotatedType(),
             "[Nullable<String>, Nullable<List<Nullable<Integer>>>, Boolean] -> OnlyConstructorBean",

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

@@ -241,4 +241,50 @@ void propagateConstraint() {
     assertThat(mutator.toString())
         .isEqualTo("[Boolean, String, Integer] -> ConstructorPropertiesAnnotatedBean");
   }
+
+  public static class CustomPair<L, R> {
+    L left;
+    R right;
+
+    public CustomPair(L left, R right) {
+      this.left = left;
+      this.right = right;
+    }
+
+    public L getLeft() {
+      return this.left;
+    }
+
+    public R getRight() {
+      return this.right;
+    }
+  }
+
+  @Test
+  void genericClass() {
+    // Note: We can't use @NotNull here since Java 8 does not retain the annotations for generic
+    // classes.
+    SerializingMutator<CustomPair<String, Integer>> mutator =
+        (SerializingMutator<CustomPair<String, Integer>>)
+            Mutators.newFactory()
+                .createOrThrow(new TypeHolder<CustomPair<String, Integer>>() {}.annotatedType());
+    assertThat(mutator.toString())
+        .isEqualTo("Nullable<[Nullable<String>, Nullable<Integer>] -> CustomPair>");
+  }
+
+  @Test
+  void genericClassLayered() {
+    // Note: We can't use @NotNull here since Java 8 does not retain the annotations for generic
+    // classes.
+    SerializingMutator<CustomPair<CustomPair<String, Boolean>, Integer>> mutator2 =
+        (SerializingMutator<CustomPair<CustomPair<String, Boolean>, Integer>>)
+            Mutators.newFactory()
+                .createOrThrow(
+                    new TypeHolder<
+                        CustomPair<CustomPair<String, Boolean>, Integer>>() {}.annotatedType());
+    assertThat(mutator2.toString())
+        .isEqualTo(
+            "Nullable<[Nullable<[Nullable<String>, Nullable<Boolean>] -> CustomPair>,"
+                + " Nullable<Integer>] -> CustomPair>");
+  }
 }

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

@@ -175,4 +175,15 @@ void propagateConstraint() {
     assertThat(mutator.toString())
         .isEqualTo("[[List<Integer>] -> PropagateInnerTypeRecord] -> PropagateTypeRecord");
   }
+
+  record GenericRecord<T>(T t) {}
+
+  @Test
+  void testGenericRecord() {
+    SerializingMutator<GenericRecord<String>> mutator =
+        (SerializingMutator<GenericRecord<String>>)
+            Mutators.newFactory()
+                .createOrThrow(new TypeHolder<@NotNull GenericRecord<String>>() {}.annotatedType());
+    assertThat(mutator.toString()).isEqualTo("[Nullable<String>] -> GenericRecord");
+  }
 }