feat: add support for generic setter based beans

Author: simonresch

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

@@ -94,10 +94,8 @@ static Optional<SerializingMutator<?>> createMutator(
             getters.length, setters.length));
     for (int i = 0; i < getters.length; i++) {
       Preconditions.check(
-          getters[i]
-              .getAnnotatedReturnType()
-              .getType()
-              .equals(setters[i].getAnnotatedParameterTypes()[0].getType()),
+          resolveReturnType(getters[i], initialType)
+              .equals(resolveParameterTypes(setters[i], initialType)[0]),
           String.format(
               "Parameter of %s does not match return type of %s", setters[i], getters[i]));
     }
@@ -107,7 +105,7 @@ static Optional<SerializingMutator<?>> createMutator(
     return createMutator(
         factory,
         newInstance.getDeclaringClass(),
-        parameterTypes(setters),
+        parameterTypes(setters, initialType),
         asInstantiationFunction(lookup, newInstance, setters),
         makeSingleGetter(unreflectMethods(lookup, getters)),
         initialType,
@@ -220,9 +218,9 @@ private static <R> Function<Object[], R> asInstantiatorFunction(
     }
   }
 
-  static AnnotatedType[] parameterTypes(Method[] methods) {
+  static AnnotatedType[] parameterTypes(Method[] methods, AnnotatedType classType) {
     return stream(methods)
-        .map(Method::getAnnotatedParameterTypes)
+        .map(m -> resolveAnnotatedParameterTypes(m, classType))
         .flatMap(Arrays::stream)
         .toArray(AnnotatedType[]::new);
   }

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

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

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

@@ -69,7 +69,7 @@ public Optional<SerializingMutator<?>> tryCreate(
                         return AggregatesHelper.createMutator(
                             factory,
                             clazz,
-                            parameterTypes(builderSetters),
+                            parameterTypes(builderSetters, type),
                             fromParametersToObject,
                             fromObjectToParameters,
                             type,

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

@@ -363,6 +363,38 @@ public String toString() {
     }
   }
 
+  public static class GenericImmutableBuilder<T> {
+    private final T t;
+
+    public GenericImmutableBuilder() {
+      t = null;
+    }
+
+    private GenericImmutableBuilder(T t) {
+      this.t = t;
+    }
+
+    public T getT() {
+      return t;
+    }
+
+    public GenericImmutableBuilder<T> setT(T t) {
+      return new GenericImmutableBuilder<T>(t);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (this == o) return true;
+      if (o == null || getClass() != o.getClass()) return false;
+      return Objects.equals(t, ((GenericImmutableBuilder<?>) o).t);
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hash(t);
+    }
+  }
+
   public static class ConstructorBasedBean {
     private final boolean foo;
     private final String bar;
@@ -914,6 +946,12 @@ void singleParam(int parameter) {}
             // Low due to int and boolean fields having very few common values during init.
             distinctElementsRatio(0.23),
             manyDistinctElements()),
+        arguments(
+            new TypeHolder<@NotNull GenericImmutableBuilder<@NotNull String>>() {}.annotatedType(),
+            "[String] -> GenericImmutableBuilder",
+            false,
+            manyDistinctElements(),
+            manyDistinctElements()),
         arguments(
             new TypeHolder<@NotNull ConstructorBasedBean>() {}.annotatedType(),
             "[Boolean, Nullable<String>, Integer] -> ConstructorBasedBean",

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

@@ -223,4 +223,27 @@ void propagateConstraint() {
         .isEqualTo(
             "[Integer, RecursionBreaking((cycle) -> RecursiveTypeBean)] -> RecursiveTypeBean");
   }
+
+  public static class Generic<T> {
+    T t;
+
+    public Generic() {}
+
+    public void setT(T t) {
+      this.t = t;
+    }
+
+    public T getT() {
+      return t;
+    }
+  }
+
+  @Test
+  void genericClass() {
+    SerializingMutator<Generic<String>> mutator =
+        (SerializingMutator<Generic<String>>)
+            Mutators.newFactory()
+                .createOrThrow(new TypeHolder<Generic<String>>() {}.annotatedType());
+    assertThat(mutator.toString()).isEqualTo("Nullable<[Nullable<String>] -> Generic>");
+  }
 }