feat: add basic mutator runtime

The idea is to extend the runtime class with more information that can
be used while mutating. For now it only contains the fuzz test method,
that is necessary for @DictionaryProvider annotation that extracts
type instances from fuzz test class functions that return Stream<?>.

Author: oetr

selffuzz/src/test/java/com/code_intelligence/selffuzz/Helpers.java

@@ -21,6 +21,7 @@
 import com.code_intelligence.selffuzz.jazzer.mutation.api.PseudoRandom;
 import com.code_intelligence.selffuzz.jazzer.mutation.api.SerializingMutator;
 import com.code_intelligence.selffuzz.jazzer.mutation.engine.SeededPseudoRandom;
+import com.code_intelligence.selffuzz.jazzer.mutation.runtime.MutatorRuntime;
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.DataInputStream;
@@ -42,4 +43,14 @@ public static <T> void assertMutator(SerializingMutator<T> mutator, byte[] data,
 
     assertEquals(crossedOver, deserialized);
   }
+
+  public static MutatorRuntime dummyMutatorRuntime() {
+    try {
+      return MutatorRuntime.forFuzzTestMethod(Helpers.class.getMethod("dummyFuzzTestMethod"));
+    } catch (NoSuchMethodException e) {
+      throw new RuntimeException(e);
+    }
+  }
+
+  public static void dummyFuzzTestMethod() {}
 }

selffuzz/src/test/java/com/code_intelligence/selffuzz/mutation/mutator/lang/FloatingPointMutatorFuzzTests.java

@@ -17,6 +17,7 @@
 package com.code_intelligence.selffuzz.mutation.mutator.lang;
 
 import static com.code_intelligence.selffuzz.Helpers.assertMutator;
+import static com.code_intelligence.selffuzz.Helpers.dummyMutatorRuntime;
 import static com.code_intelligence.selffuzz.jazzer.mutation.support.TypeSupport.withExtraAnnotations;
 import static org.junit.jupiter.api.Assumptions.assumeTrue;
 
@@ -42,6 +43,7 @@ public void doubleMutatorTest(double min, double max, long seed, byte @NotNull [
         (SerializingMutator<Double>)
             Mutators.newFactory()
                 .createOrThrow(
+                    dummyMutatorRuntime(),
                     withExtraAnnotations(
                         new TypeHolder<@NotNull Double>() {}.annotatedType(), range));
     assertMutator(mutator, data, seed);
@@ -56,6 +58,7 @@ public void floatMutatorTest(float min, float max, long seed, byte @NotNull [] d
         (SerializingMutator<Float>)
             Mutators.newFactory()
                 .createOrThrow(
+                    dummyMutatorRuntime(),
                     withExtraAnnotations(
                         new TypeHolder<@NotNull Float>() {}.annotatedType(), range));
     assertMutator(mutator, data, seed);

selffuzz/src/test/java/com/code_intelligence/selffuzz/mutation/mutator/lang/StringMutatorFuzzTest.java

@@ -17,6 +17,7 @@
 package com.code_intelligence.selffuzz.mutation.mutator.lang;
 
 import static com.code_intelligence.selffuzz.Helpers.assertMutator;
+import static com.code_intelligence.selffuzz.Helpers.dummyMutatorRuntime;
 
 import com.code_intelligence.jazzer.junit.FuzzTest;
 import com.code_intelligence.selffuzz.jazzer.mutation.annotation.NotNull;
@@ -31,7 +32,8 @@ class StringMutatorFuzzTest {
   void stringMutatorTest(long seed, byte @NotNull [] data) throws IOException {
     SerializingMutator<String> mutator =
         (SerializingMutator<String>)
-            Mutators.newFactory().createOrThrow(new TypeHolder<String>() {}.annotatedType());
+            Mutators.newFactory()
+                .createOrThrow(dummyMutatorRuntime(), new TypeHolder<String>() {}.annotatedType());
     assertMutator(mutator, data, seed);
   }
 }

selffuzz/src/test/java/com/code_intelligence/selffuzz/mutation/mutator/proto/ProtobufMutatorFuzzTest.java

@@ -17,6 +17,7 @@
 package com.code_intelligence.selffuzz.mutation.mutator.proto;
 
 import static com.code_intelligence.selffuzz.Helpers.assertMutator;
+import static com.code_intelligence.selffuzz.Helpers.dummyMutatorRuntime;
 
 import com.code_intelligence.jazzer.junit.FuzzTest;
 import com.code_intelligence.selffuzz.jazzer.mutation.annotation.NotNull;
@@ -63,6 +64,7 @@ void protobufMutatorTest(long seed, @NotNull DescriptorProto messageType, byte @
           (SerializingMutator<DynamicMessage>)
               Mutators.newFactory()
                   .createOrThrow(
+                      dummyMutatorRuntime(),
                       new TypeHolder<
                           @WithDefaultInstance(
                               "com.code_intelligence.selffuzz.mutation.mutator.proto.ProtobufMutatorFuzzTest#getDefaultInstance")

src/main/java/com/code_intelligence/jazzer/mutation/ArgumentsMutator.java

@@ -30,6 +30,7 @@
 import com.code_intelligence.jazzer.mutation.combinator.MutatorCombinators;
 import com.code_intelligence.jazzer.mutation.engine.SeededPseudoRandom;
 import com.code_intelligence.jazzer.mutation.mutator.Mutators;
+import com.code_intelligence.jazzer.mutation.runtime.MutatorRuntime;
 import com.code_intelligence.jazzer.mutation.support.Preconditions;
 import com.code_intelligence.jazzer.utils.Log;
 import java.io.ByteArrayInputStream;
@@ -97,11 +98,13 @@ public static Optional<ArgumentsMutator> forMethod(
       Log.error(validationError.getMessage());
       throw validationError;
     }
+    MutatorRuntime runtime = MutatorRuntime.forFuzzTestMethod(method);
     return toArrayOrEmpty(
             stream(method.getAnnotatedParameterTypes())
                 .map(
                     type -> {
-                      Optional<SerializingMutator<?>> mutator = mutatorFactory.tryCreate(type);
+                      Optional<SerializingMutator<?>> mutator =
+                          mutatorFactory.tryCreate(runtime, type);
                       if (!mutator.isPresent()) {
                         Log.error(
                             String.format(

src/main/java/com/code_intelligence/jazzer/mutation/BUILD.bazel

@@ -11,6 +11,7 @@ java_library(
         "//src/main/java/com/code_intelligence/jazzer/mutation/combinator",
         "//src/main/java/com/code_intelligence/jazzer/mutation/engine",
         "//src/main/java/com/code_intelligence/jazzer/mutation/mutator",
+        "//src/main/java/com/code_intelligence/jazzer/mutation/runtime",
         "//src/main/java/com/code_intelligence/jazzer/mutation/support",
         "//src/main/java/com/code_intelligence/jazzer/utils:log",
     ],

src/main/java/com/code_intelligence/jazzer/mutation/api/BUILD.bazel

@@ -3,6 +3,7 @@ java_library(
     srcs = glob(["*.java"]),
     visibility = ["//visibility:public"],
     deps = [
+        "//src/main/java/com/code_intelligence/jazzer/mutation/runtime",
         "//src/main/java/com/code_intelligence/jazzer/mutation/support",
         "@maven//:com_google_errorprone_error_prone_annotations",
     ],

src/main/java/com/code_intelligence/jazzer/mutation/api/ExtendedMutatorFactory.java

@@ -19,6 +19,7 @@
 import static com.code_intelligence.jazzer.mutation.support.Preconditions.require;
 import static java.lang.String.format;
 
+import com.code_intelligence.jazzer.mutation.runtime.MutatorRuntime;
 import com.google.errorprone.annotations.CheckReturnValue;
 import java.lang.reflect.AnnotatedType;
 import java.util.Optional;
@@ -35,14 +36,15 @@ public Cache getCache() {
     return cache;
   }
 
-  public final SerializingMutator<?> createOrThrow(AnnotatedType type) {
-    Optional<SerializingMutator<?>> maybeMutator = tryCreate(type);
+  public final SerializingMutator<?> createOrThrow(MutatorRuntime runtime, AnnotatedType type) {
+    Optional<SerializingMutator<?>> maybeMutator = tryCreate(runtime, type);
     require(maybeMutator.isPresent(), "Failed to create mutator for " + type);
     return maybeMutator.get();
   }
 
-  public final SerializingInPlaceMutator<?> createInPlaceOrThrow(AnnotatedType type) {
-    Optional<SerializingInPlaceMutator<?>> maybeMutator = tryCreateInPlace(type);
+  public final SerializingInPlaceMutator<?> createInPlaceOrThrow(
+      MutatorRuntime runtime, AnnotatedType type) {
+    Optional<SerializingInPlaceMutator<?>> maybeMutator = tryCreateInPlace(runtime, type);
     require(maybeMutator.isPresent(), "Failed to create mutator for " + type);
     return maybeMutator.get();
   }
@@ -51,8 +53,9 @@ public final SerializingInPlaceMutator<?> createInPlaceOrThrow(AnnotatedType typ
    * Tries to create a mutator for {@code type} and, if successful, asserts that it is an instance
    * of {@link SerializingInPlaceMutator}.
    */
-  public final Optional<SerializingInPlaceMutator<?>> tryCreateInPlace(AnnotatedType type) {
-    return tryCreate(type)
+  public final Optional<SerializingInPlaceMutator<?>> tryCreateInPlace(
+      MutatorRuntime runtime, AnnotatedType type) {
+    return tryCreate(runtime, type)
         .map(
             mutator -> {
               require(
@@ -63,8 +66,9 @@ public final Optional<SerializingInPlaceMutator<?>> tryCreateInPlace(AnnotatedTy
   }
 
   @CheckReturnValue
-  public final Optional<SerializingMutator<?>> tryCreate(AnnotatedType type) {
-    return tryCreate(type, this);
+  public final Optional<SerializingMutator<?>> tryCreate(
+      MutatorRuntime runtime, AnnotatedType type) {
+    return tryCreate(runtime, type, this);
   }
 
   public abstract void internMutator(SerializingMutator<?> mutator);

src/main/java/com/code_intelligence/jazzer/mutation/api/MutatorFactory.java

@@ -16,6 +16,7 @@
 
 package com.code_intelligence.jazzer.mutation.api;
 
+import com.code_intelligence.jazzer.mutation.runtime.MutatorRuntime;
 import com.google.errorprone.annotations.CheckReturnValue;
 import java.lang.reflect.AnnotatedType;
 import java.util.Optional;
@@ -35,14 +36,15 @@ public interface MutatorFactory {
    *     this factory can't create such mutators
    */
   @CheckReturnValue
-  Optional<SerializingMutator<?>> tryCreate(AnnotatedType type, ExtendedMutatorFactory factory);
+  Optional<SerializingMutator<?>> tryCreate(
+      MutatorRuntime runtime, AnnotatedType type, ExtendedMutatorFactory factory);
 
   /**
    * This exception can be thrown in mutator constructors to indicate that they failed to construct
    * a child mutator. This should be treated by callers as the equivalent of returning {@link
-   * Optional#empty()} from {@link #tryCreate(AnnotatedType, ExtendedMutatorFactory)}, which may not
-   * be possible in mutator factories for recursive structures that need to create child mutators in
-   * a mutators constructor.
+   * Optional#empty()} from {@link #tryCreate(MutatorRuntime, AnnotatedType,
+   * ExtendedMutatorFactory)}, which may not be possible in mutator factories for recursive
+   * structures that need to create child mutators in a mutators constructor.
    */
   final class FailedToConstructChildMutatorException extends RuntimeException {
     public FailedToConstructChildMutatorException() {

src/main/java/com/code_intelligence/jazzer/mutation/engine/BUILD.bazel

@@ -10,6 +10,7 @@ java_library(
         "//src/main/java/com/code_intelligence/jazzer/mutation/annotation",
         "//src/main/java/com/code_intelligence/jazzer/mutation/api",
         "//src/main/java/com/code_intelligence/jazzer/mutation/combinator",
+        "//src/main/java/com/code_intelligence/jazzer/mutation/runtime",
         "//src/main/java/com/code_intelligence/jazzer/mutation/support",
         "//src/main/java/com/code_intelligence/jazzer/utils:log",
         "@maven//:com_google_errorprone_error_prone_annotations",