feat: allow creation of parameterized and generic array types

In addition to primitive arrays, these types are now also supported:
- List<Integer> []
- List<Integer> [][][]

Author: oetr

selffuzz/src/test/java/com/code_intelligence/selffuzz/mutation/ArgumentsMutatorFuzzTest.java

@@ -271,6 +271,17 @@ void fuzz_MapField3(Proto3.MapField3 o1) {}
   public static void fuzz_MutuallyReferringProtobufs(
       Proto2.TestProtobuf o1, Proto2.TestSubProtobuf o2) {}
 
+  @SelfFuzzTest
+  void fuzzStrings(
+      @NotNull @WithSize(max = 3)
+          List<String> @NotNull @WithLength(max = 4) [] arrayOfListOfStrings,
+      @NotNull @WithSize(max = 1)
+          List<Integer> @NotNull @WithLength(max = 2) [] @NotNull @WithLength(max = 3) []
+              arrayOfArraysOfListOfIntegers) {
+    assertThat(arrayOfListOfStrings.length).isAtMost(4);
+    assertThat(arrayOfArraysOfListOfIntegers.length).isAtMost(2);
+  }
+
   /**
    * @return all methods in this class annotated by @SelfFuzzTest. If any of those methods are
    *     annotated by @Solo, only those are returned.

src/main/java/com/code_intelligence/jazzer/mutation/mutator/collection/ArrayMutatorFactory.java

@@ -19,6 +19,7 @@
 import static com.code_intelligence.jazzer.mutation.mutator.collection.ChunkMutations.MutationAction.pickRandomMutationAction;
 import static com.code_intelligence.jazzer.mutation.support.Preconditions.require;
 import static com.code_intelligence.jazzer.mutation.support.PropertyConstraintSupport.propagatePropertyConstraints;
+import static com.code_intelligence.jazzer.mutation.support.TypeSupport.extractRawClass;
 import static java.lang.Math.min;
 import static java.lang.String.format;
 
@@ -35,6 +36,7 @@
 import java.lang.reflect.AnnotatedArrayType;
 import java.lang.reflect.AnnotatedType;
 import java.lang.reflect.Array;
+import java.lang.reflect.Type;
 import java.util.Arrays;
 import java.util.Optional;
 import java.util.function.Predicate;
@@ -53,12 +55,16 @@ public Optional<SerializingMutator<?>> tryCreate(
 
     AnnotatedType elementType = ((AnnotatedArrayType) type).getAnnotatedGenericComponentType();
     AnnotatedType propagatedElementType = propagatePropertyConstraints(type, elementType);
-    Class<?> propagatedElementClazz = (Class<?>) propagatedElementType.getType();
-    return Optional.of(propagatedElementType)
-        .flatMap(factory::tryCreate)
-        .map(
-            elementMutator ->
-                new ArrayMutator<>(elementMutator, propagatedElementClazz, minLength, maxLength));
+    Type rawType = propagatedElementType.getType();
+    return extractRawClass(rawType)
+        .flatMap(
+            propagatedElementClass ->
+                Optional.of(propagatedElementType)
+                    .flatMap(factory::tryCreate)
+                    .map(
+                        elementMutator ->
+                            new ArrayMutator<>(
+                                elementMutator, propagatedElementClass, minLength, maxLength)));
   }
 
   enum CrossOverAction {

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

@@ -37,9 +37,12 @@
 import java.lang.reflect.AnnotatedTypeVariable;
 import java.lang.reflect.AnnotatedWildcardType;
 import java.lang.reflect.Array;
+import java.lang.reflect.GenericArrayType;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;
+import java.lang.reflect.TypeVariable;
+import java.lang.reflect.WildcardType;
 import java.util.ArrayDeque;
 import java.util.Arrays;
 import java.util.Collections;
@@ -687,4 +690,21 @@ public static boolean annotatedTypeEquals(AnnotatedType left, AnnotatedType righ
     return left.getType().equals(right.getType())
         && Arrays.equals(left.getAnnotations(), right.getAnnotations());
   }
+
+  public static Optional<Class<?>> extractRawClass(Type type) {
+    if (type instanceof Class<?>) {
+      return Optional.of((Class<?>) type);
+    } else if (type instanceof ParameterizedType) {
+      return Optional.of((Class<?>) ((ParameterizedType) type).getRawType());
+    } else if (type instanceof GenericArrayType) {
+      Type componentType = ((GenericArrayType) type).getGenericComponentType();
+      Optional<Class<?>> componentClass = extractRawClass(componentType);
+      return componentClass.map(aClass -> Array.newInstance(aClass, 0).getClass());
+    } else if (type instanceof TypeVariable<?> || type instanceof WildcardType) {
+      // Default fallback — assume Object array
+      return Optional.of(Object.class);
+    } else {
+      return Optional.empty();
+    }
+  }
 }

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

@@ -582,6 +582,12 @@ null, emptyList(), singletonList(null), singletonList(false), singletonList(true
             false,
             distinctElementsRatio(0.30),
             distinctElementsRatio(0.30)),
+        arguments(
+            new TypeHolder<@NotNull List<@NotNull Integer> @NotNull []>() {}.annotatedType(),
+            "List<Integer>[]",
+            false,
+            manyDistinctElements(),
+            distinctElementsRatio(0.66)),
         arguments(
             new TypeHolder<@NotNull TestEnumThree @NotNull []>() {}.annotatedType(),
             "Enum<TestEnumThree>[]",