mutation: Simplify ArgumentsMutator by not storing the instance

Author: fmeum

src/jmh/java/com/code_intelligence/jazzer/mutation/MutatorBenchmark.java

@@ -58,7 +58,7 @@ public static class BenchmarkState {
     @Setup(Level.Iteration)
     public void setUp() throws NoSuchMethodException {
       mutator =
-          ArgumentsMutator.forStaticMethodOrThrow(
+          ArgumentsMutator.forMethodOrThrow(
               MutatorBenchmark.class.getMethod("fuzzMinimal", List.class));
     }
   }
@@ -70,7 +70,7 @@ public void mutateDetachInvoke(BenchmarkState state) throws Throwable {
     mutator.init(prng);
     for (int i = 0; i < state.mutations; i++) {
       mutator.mutate(prng);
-      mutator.invoke(true);
+      mutator.invoke(null, true);
     }
   }
 
@@ -88,7 +88,7 @@ public void mutateReadInvokeWrite(BenchmarkState state) throws Throwable {
       out.reset();
       mutator.write(out);
       buffer = out.toByteArray();
-      mutator.invoke(false);
+      mutator.invoke(null, false);
     }
   }
 }

src/main/java/com/code_intelligence/jazzer/driver/FuzzTargetRunner.java

@@ -38,7 +38,6 @@
 import java.io.IOException;
 import java.lang.invoke.MethodHandle;
 import java.lang.invoke.MethodHandles;
-import java.lang.reflect.Modifier;
 import java.math.BigInteger;
 import java.nio.charset.StandardCharsets;
 import java.security.MessageDigest;
@@ -159,11 +158,7 @@ public final class FuzzTargetRunner {
     }
 
     if (useExperimentalMutator) {
-      if (Modifier.isStatic(fuzzTarget.method.getModifiers())) {
-        mutator = ArgumentsMutator.forStaticMethodOrThrow(fuzzTarget.method);
-      } else {
-        mutator = ArgumentsMutator.forInstanceMethodOrThrow(fuzzTargetInstance, fuzzTarget.method);
-      }
+      mutator = ArgumentsMutator.forMethodOrThrow(fuzzTarget.method);
       Log.info("Using experimental mutator: " + mutator);
     } else {
       mutator = null;
@@ -242,7 +237,7 @@ private static int runOne(long dataPtr, int dataLength) {
       if (useExperimentalMutator) {
         // No need to detach as we are currently reading in the mutator state from bytes in every
         // iteration.
-        mutator.invoke(false);
+        mutator.invoke(fuzzTargetInstance, false);
       } else if (fuzzTargetInstance == null) {
         fuzzTargetMethod.invoke(argument);
       } else {

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

@@ -22,7 +22,6 @@
 import static com.code_intelligence.jazzer.mutation.support.StreamSupport.toArrayOrEmpty;
 import static java.lang.String.format;
 import static java.util.Arrays.stream;
-import static java.util.Objects.requireNonNull;
 import static java.util.stream.Collectors.joining;
 
 import com.code_intelligence.jazzer.mutation.api.MutatorFactory;
@@ -42,11 +41,9 @@
 import java.lang.reflect.AnnotatedType;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
-import java.lang.reflect.Modifier;
 import java.util.Optional;
 
 public final class ArgumentsMutator {
-  private final Object instance;
   private final Method method;
   private final ProductMutator productMutator;
   private Object[] arguments;
@@ -60,8 +57,7 @@ public final class ArgumentsMutator {
    */
   private boolean argumentsExposed;
 
-  private ArgumentsMutator(Object instance, Method method, ProductMutator productMutator) {
-    this.instance = instance;
+  private ArgumentsMutator(Method method, ProductMutator productMutator) {
     this.method = method;
     this.productMutator = productMutator;
   }
@@ -74,44 +70,19 @@ private static String prettyPrintMethod(Method method) {
         stream(method.getAnnotatedParameterTypes()).map(Object::toString).collect(joining(", ")));
   }
 
-  public static ArgumentsMutator forInstanceMethodOrThrow(Object instance, Method method) {
-    return forInstanceMethod(Mutators.newFactory(), instance, method)
-        .orElseThrow(
-            () ->
-                new IllegalArgumentException(
-                    "Failed to construct mutator for " + prettyPrintMethod(method)));
-  }
-
-  public static ArgumentsMutator forStaticMethodOrThrow(Method method) {
-    return forStaticMethod(Mutators.newFactory(), method)
+  public static ArgumentsMutator forMethodOrThrow(Method method) {
+    return forMethod(Mutators.newFactory(), method)
         .orElseThrow(
             () ->
                 new IllegalArgumentException(
                     "Failed to construct mutator for " + prettyPrintMethod(method)));
   }
 
   public static Optional<ArgumentsMutator> forMethod(Method method) {
-    return forMethod(Mutators.newFactory(), null, method);
+    return forMethod(Mutators.newFactory(), method);
   }
 
-  public static Optional<ArgumentsMutator> forInstanceMethod(
-      MutatorFactory mutatorFactory, Object instance, Method method) {
-    require(!isStatic(method), "method must not be static");
-    requireNonNull(instance, "instance must not be null");
-    require(
-        method.getDeclaringClass().isInstance(instance),
-        format("instance is a %s, expected %s", instance.getClass(), method.getDeclaringClass()));
-    return forMethod(mutatorFactory, instance, method);
-  }
-
-  public static Optional<ArgumentsMutator> forStaticMethod(
-      MutatorFactory mutatorFactory, Method method) {
-    require(isStatic(method), "method must be static");
-    return forMethod(mutatorFactory, null, method);
-  }
-
-  public static Optional<ArgumentsMutator> forMethod(
-      MutatorFactory mutatorFactory, Object instance, Method method) {
+  public static Optional<ArgumentsMutator> forMethod(MutatorFactory mutatorFactory, Method method) {
     require(method.getParameterCount() > 0, "Can't fuzz method without parameters: " + method);
     for (AnnotatedType parameter : method.getAnnotatedParameterTypes()) {
       validateAnnotationUsage(parameter);
@@ -120,18 +91,13 @@ public static Optional<ArgumentsMutator> forMethod(
             stream(method.getAnnotatedParameterTypes()).map(mutatorFactory::tryCreate),
             SerializingMutator<?>[]::new)
         .map(MutatorCombinators::mutateProduct)
-        .map(productMutator -> ArgumentsMutator.create(instance, method, productMutator));
+        .map(productMutator -> ArgumentsMutator.create(method, productMutator));
   }
 
-  private static ArgumentsMutator create(
-      Object instance, Method method, ProductMutator productMutator) {
+  private static ArgumentsMutator create(Method method, ProductMutator productMutator) {
     method.setAccessible(true);
 
-    return new ArgumentsMutator(instance, method, productMutator);
-  }
-
-  private static boolean isStatic(Method method) {
-    return Modifier.isStatic(method.getModifiers());
+    return new ArgumentsMutator(method, productMutator);
   }
 
   /**
@@ -203,7 +169,7 @@ void mutate(PseudoRandom prng) {
     productMutator.mutateInPlace(arguments, prng);
   }
 
-  public void invoke(boolean detach) throws Throwable {
+  public void invoke(Object instance, boolean detach) throws Throwable {
     Object[] invokeArguments;
     if (detach) {
       invokeArguments = productMutator.detach(arguments);

src/test/java/com/code_intelligence/jazzer/mutation/ArgumentsMutatorTest.java

@@ -48,7 +48,7 @@ void testStaticMethod() throws Throwable {
     Method method =
         ArgumentsMutatorTest.class.getMethod("fuzzThisFunction", List.class, List.class);
     Optional<ArgumentsMutator> maybeMutator =
-        ArgumentsMutator.forStaticMethod(Mutators.newFactory(), method);
+        ArgumentsMutator.forMethod(Mutators.newFactory(), method);
     assertThat(maybeMutator).isPresent();
     ArgumentsMutator mutator = maybeMutator.get();
 
@@ -77,7 +77,7 @@ void testStaticMethod() throws Throwable {
 
     fuzzThisFunctionArgument1 = null;
     fuzzThisFunctionArgument2 = null;
-    mutator.invoke(true);
+    mutator.invoke(this, true);
     assertThat(fuzzThisFunctionArgument1).containsExactly(singletonList(true));
     assertThat(fuzzThisFunctionArgument2).containsExactly(false);
 
@@ -106,7 +106,7 @@ void testStaticMethod() throws Throwable {
 
     fuzzThisFunctionArgument1 = null;
     fuzzThisFunctionArgument2 = null;
-    mutator.invoke(true);
+    mutator.invoke(this, true);
     assertThat(fuzzThisFunctionArgument1).containsExactly(singletonList(false));
     assertThat(fuzzThisFunctionArgument2).containsExactly(false);
 
@@ -139,7 +139,7 @@ void testStaticMethod() throws Throwable {
 
     fuzzThisFunctionArgument1 = null;
     fuzzThisFunctionArgument2 = null;
-    mutator.invoke(false);
+    mutator.invoke(this, false);
     assertThat(fuzzThisFunctionArgument1).containsExactly(singletonList(true));
     assertThat(fuzzThisFunctionArgument2).containsExactly(false);
   }
@@ -157,7 +157,7 @@ void testInstanceMethod() throws Throwable {
     Method method =
         ArgumentsMutatorTest.class.getMethod("mutableFuzzThisFunction", List.class, List.class);
     Optional<ArgumentsMutator> maybeMutator =
-        ArgumentsMutator.forInstanceMethod(Mutators.newFactory(), this, method);
+        ArgumentsMutator.forMethod(Mutators.newFactory(), method);
     assertThat(maybeMutator).isPresent();
     ArgumentsMutator mutator = maybeMutator.get();
 
@@ -186,7 +186,7 @@ void testInstanceMethod() throws Throwable {
 
     mutableFuzzThisFunctionArgument1 = null;
     mutableFuzzThisFunctionArgument2 = null;
-    mutator.invoke(true);
+    mutator.invoke(this, true);
     assertThat(mutableFuzzThisFunctionArgument1).containsExactly(singletonList(true));
     assertThat(mutableFuzzThisFunctionArgument2).containsExactly(false);
 
@@ -215,7 +215,7 @@ void testInstanceMethod() throws Throwable {
 
     mutableFuzzThisFunctionArgument1 = null;
     mutableFuzzThisFunctionArgument2 = null;
-    mutator.invoke(true);
+    mutator.invoke(this, true);
     assertThat(mutableFuzzThisFunctionArgument1).containsExactly(singletonList(false));
     assertThat(mutableFuzzThisFunctionArgument2).containsExactly(false);
 
@@ -248,7 +248,7 @@ void testInstanceMethod() throws Throwable {
 
     mutableFuzzThisFunctionArgument1 = null;
     mutableFuzzThisFunctionArgument2 = null;
-    mutator.invoke(false);
+    mutator.invoke(this, false);
     assertThat(mutableFuzzThisFunctionArgument1).containsExactly(singletonList(true));
     assertThat(mutableFuzzThisFunctionArgument2).containsExactly(false);
   }
@@ -261,7 +261,7 @@ public void crossOverFunction(List<Boolean> list) {}
   void testCrossOver() throws Throwable {
     Method method = ArgumentsMutatorTest.class.getMethod("crossOverFunction", List.class);
     Optional<ArgumentsMutator> maybeMutator =
-        ArgumentsMutator.forInstanceMethod(Mutators.newFactory(), this, method);
+        ArgumentsMutator.forMethod(Mutators.newFactory(), method);
     assertThat(maybeMutator).isPresent();
     ArgumentsMutator mutator = maybeMutator.get();