feat: add basic mutator runtime

Propagate a new class MutatorRuntime to every mutator. For now the
class only contains the fuzz test method, necessary for implementation
of @DictionaryProvider annotation, in order to extract thunks
returning Stream<?>.
This class can be extended in the future to contain the table of
recent compares, etc. to improve fuzzing performance.

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",