mutation: Add hasFixedSize() method to all mutators

This function will be used in a follow-up change to allow collection
mutators to decide how "aggressive" they should be when mutating and
resizing the collection.

Author: fmeum

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

@@ -75,4 +75,13 @@ public interface InPlaceMutator<T> extends Debuggable {
    * </ul>
    */
   void crossOverInPlace(T reference, T otherReference, PseudoRandom prng);
+
+  /**
+   * Whether the type {@code T} mutated by this mutator has a fixed size in memory. This information
+   * can be used by mutators for collections of {@code T}s.
+   *
+   * <p>Examples of types with fixed size include primitive types, enums, and classes with only
+   * primitive types and enums as members.
+   */
+  boolean hasFixedSize();
 }

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

@@ -41,6 +41,7 @@
  * @param <T> the type this mutator operates on
  */
 public interface ValueMutator<T> extends Debuggable {
+
   /**
    * Implementations
    *
@@ -79,4 +80,13 @@ public interface ValueMutator<T> extends Debuggable {
    */
   @CheckReturnValue
   T crossOver(T value, T otherValue, PseudoRandom prng);
+
+  /**
+   * Whether the type {@code T} mutated by this mutator has a fixed size in memory. This information
+   * can be used by mutators for collections of {@code T}s.
+   *
+   * <p>Examples of types with fixed size include primitive types, enums, and classes with only
+   * primitive types and enums as members.
+   */
+  boolean hasFixedSize();
 }

src/main/java/com/code_intelligence/jazzer/mutation/combinator/MutatorCombinators.java

@@ -87,6 +87,11 @@ public void crossOverInPlace(T reference, T otherReference, PseudoRandom prng) {
         setter.accept(reference, crossedOver);
       }
 
+      @Override
+      public boolean hasFixedSize() {
+        return mutator.hasFixedSize();
+      }
+
       @Override
       public String toDebugString(Predicate<Debuggable> isInCycle) {
         Class<?> owningType =
@@ -121,6 +126,11 @@ public void crossOverInPlace(T reference, T otherReference, PseudoRandom prng) {
         mutator.crossOverInPlace(map.apply(reference), map.apply(otherReference), prng);
       }
 
+      @Override
+      public boolean hasFixedSize() {
+        return mutator.hasFixedSize();
+      }
+
       @Override
       public String toDebugString(Predicate<Debuggable> isInCycle) {
         Class<?> owningType = TypeResolver.resolveRawArguments(Function.class, map.getClass())[0];
@@ -155,6 +165,11 @@ public void mutateInPlace(T reference, PseudoRandom prng) {}
         @Override
         public void crossOverInPlace(T reference, T otherReference, PseudoRandom prng) {}
 
+        @Override
+        public boolean hasFixedSize() {
+          return true;
+        }
+
         @Override
         public String toDebugString(Predicate<Debuggable> isInCycle) {
           return "{<empty>}";
@@ -167,6 +182,7 @@ public String toString() {
       };
     }
 
+    boolean hasFixedSize = stream(partialMutators).allMatch(InPlaceMutator::hasFixedSize);
     final InPlaceMutator<T>[] mutators = Arrays.copyOf(partialMutators, partialMutators.length);
     return new InPlaceMutator<T>() {
       @Override
@@ -188,6 +204,11 @@ public void crossOverInPlace(T reference, T otherReference, PseudoRandom prng) {
         }
       }
 
+      @Override
+      public boolean hasFixedSize() {
+        return hasFixedSize;
+      }
+
       @Override
       public String toDebugString(Predicate<Debuggable> isInCycle) {
         return stream(mutators)
@@ -281,6 +302,11 @@ public Integer crossOver(Integer value, Integer otherValue, PseudoRandom prng) {
         return prng.choice() ? value : otherValue;
       }
 
+      @Override
+      public boolean hasFixedSize() {
+        return true;
+      }
+
       @Override
       public String toDebugString(Predicate<Debuggable> isInCycle) {
         return "mutateIndices(" + length + ")";
@@ -309,6 +335,7 @@ public static ProductMutator mutateProduct(SerializingMutator... mutators) {
   @SafeVarargs
   public static <T> InPlaceMutator<T> mutateSumInPlace(
       ToIntFunction<T> getState, InPlaceMutator<T>... perStateMutators) {
+    boolean hasFixedSize = stream(perStateMutators).allMatch(InPlaceMutator::hasFixedSize);
     final InPlaceMutator<T>[] mutators = Arrays.copyOf(perStateMutators, perStateMutators.length);
     return new InPlaceMutator<T>() {
       @Override
@@ -349,6 +376,11 @@ public void crossOverInPlace(T reference, T otherReference, PseudoRandom prng) {
         }
       }
 
+      @Override
+      public boolean hasFixedSize() {
+        return hasFixedSize;
+      }
+
       @Override
       public String toDebugString(Predicate<Debuggable> isInCycle) {
         return stream(mutators)
@@ -383,6 +415,11 @@ public void mutateInPlace(T reference, PseudoRandom prng) {
       public void crossOverInPlace(T reference, T otherReference, PseudoRandom prng) {
         mutator.crossOverInPlace(reference, otherReference, prng);
       }
+
+      @Override
+      public boolean hasFixedSize() {
+        return mutator.hasFixedSize();
+      }
     };
   }
 
@@ -426,6 +463,11 @@ public T mutate(T value, PseudoRandom prng) {
       public T crossOver(T value, T otherValue, PseudoRandom prng) {
         return value;
       }
+
+      @Override
+      public boolean hasFixedSize() {
+        return true;
+      }
     };
   }
 
@@ -440,32 +482,39 @@ public T crossOver(T value, T otherValue, PseudoRandom prng) {
    * @param serializer implementation of the {@link Serializer<T>} part
    * @param lazyMutator supplies the implementation of the {@link InPlaceMutator<T>} part. This is
    *     guaranteed to be invoked exactly once and only after {@code registerSelf}.
+   * @param hasFixedSize the value to return from the resulting mutators {@link
+   *     InPlaceMutator#hasFixedSize()}
    */
   public static <T> SerializingInPlaceMutator<T> assemble(
       Consumer<SerializingInPlaceMutator<T>> registerSelf,
       Supplier<T> makeDefaultInstance,
       Serializer<T> serializer,
-      Supplier<InPlaceMutator<T>> lazyMutator) {
+      Supplier<InPlaceMutator<T>> lazyMutator,
+      boolean hasFixedSize) {
     return new DelegatingSerializingInPlaceMutator<>(
-        registerSelf, makeDefaultInstance, serializer, lazyMutator);
+        registerSelf, makeDefaultInstance, serializer, lazyMutator, hasFixedSize);
   }
 
   private static class DelegatingSerializingInPlaceMutator<T> extends SerializingInPlaceMutator<T> {
     private final Supplier<T> makeDefaultInstance;
     private final Serializer<T> serializer;
     private final InPlaceMutator<T> mutator;
+    private final boolean hasFixedSize;
 
     private DelegatingSerializingInPlaceMutator(
         Consumer<SerializingInPlaceMutator<T>> registerSelf,
         Supplier<T> makeDefaultInstance,
         Serializer<T> serializer,
-        Supplier<InPlaceMutator<T>> lazyMutator) {
+        Supplier<InPlaceMutator<T>> lazyMutator,
+        boolean hasFixedSize) {
       requireNonNull(makeDefaultInstance);
       requireNonNull(serializer);
 
       registerSelf.accept(this);
       this.makeDefaultInstance = makeDefaultInstance;
       this.serializer = serializer;
+      // Set before invoking the supplier as that can result in calls to hasFixedSize().
+      this.hasFixedSize = hasFixedSize;
       this.mutator = lazyMutator.get();
     }
 
@@ -484,6 +533,13 @@ public void crossOverInPlace(T reference, T otherReference, PseudoRandom prng) {
       mutator.crossOverInPlace(reference, otherReference, prng);
     }
 
+    @Override
+    public boolean hasFixedSize() {
+      // This uses a fixed value rather than calling mutator.hasFixedSize() as this method is called
+      // before the constructor has finished, which is necessary in the case of a cycle.
+      return hasFixedSize;
+    }
+
     @Override
     protected T makeDefaultInstance() {
       return makeDefaultInstance.get();

src/main/java/com/code_intelligence/jazzer/mutation/combinator/PostComposedMutator.java

@@ -61,6 +61,11 @@ public R crossOver(R value, R otherValue, PseudoRandom prng) {
     return map.apply(mutator.crossOver(inverse.apply(value), inverse.apply(otherValue), prng));
   }
 
+  @Override
+  public boolean hasFixedSize() {
+    return mutator.hasFixedSize();
+  }
+
   @Override
   public final R read(DataInputStream in) throws IOException {
     return map.apply(mutator.read(in));

src/main/java/com/code_intelligence/jazzer/mutation/combinator/ProductMutator.java

@@ -26,6 +26,7 @@
 import com.code_intelligence.jazzer.mutation.api.PseudoRandom;
 import com.code_intelligence.jazzer.mutation.api.SerializingInPlaceMutator;
 import com.code_intelligence.jazzer.mutation.api.SerializingMutator;
+import com.code_intelligence.jazzer.mutation.api.ValueMutator;
 import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
@@ -40,11 +41,13 @@ public final class ProductMutator extends SerializingInPlaceMutator<Object[]> {
   private static final int INVERSE_PICK_VALUE_SUPPLIER_FREQUENCY = 100;
 
   private final SerializingMutator[] mutators;
+  private final boolean hasFixedSize;
 
   ProductMutator(SerializingMutator[] mutators) {
     requireNonNullElements(mutators);
     require(mutators.length > 0, "mutators must not be empty");
     this.mutators = Arrays.copyOf(mutators, mutators.length);
+    this.hasFixedSize = stream(mutators).allMatch(ValueMutator::hasFixedSize);
   }
 
   @Override
@@ -124,6 +127,11 @@ public void crossOverInPlace(Object[] reference, Object[] otherReference, Pseudo
     }
   }
 
+  @Override
+  public boolean hasFixedSize() {
+    return hasFixedSize;
+  }
+
   @Override
   public Object[] detach(Object[] value) {
     Object[] clone = new Object[mutators.length];

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

@@ -146,6 +146,11 @@ public void crossOverInPlace(List<T> reference, List<T> otherReference, PseudoRa
       }
     }
 
+    @Override
+    public boolean hasFixedSize() {
+      return false;
+    }
+
     @Override
     public List<T> detach(List<T> value) {
       return value.stream()

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

@@ -193,6 +193,11 @@ public void crossOverInPlace(Map<K, V> reference, Map<K, V> otherReference, Pseu
       }
     }
 
+    @Override
+    public boolean hasFixedSize() {
+      return false;
+    }
+
     @Override
     public Map<K, V> detach(Map<K, V> value) {
       return value.entrySet().stream()

src/main/java/com/code_intelligence/jazzer/mutation/mutator/lang/BooleanMutatorFactory.java

@@ -66,6 +66,11 @@ public Boolean crossOver(Boolean value, Boolean otherValue, PseudoRandom prng) {
       return prng.choice() ? value : otherValue;
     }
 
+    @Override
+    public boolean hasFixedSize() {
+      return true;
+    }
+
     @Override
     public String toDebugString(Predicate<Debuggable> isInLoop) {
       return "Boolean";

src/main/java/com/code_intelligence/jazzer/mutation/mutator/lang/ByteArrayMutatorFactory.java

@@ -219,6 +219,11 @@ private static byte[] overwritePart(byte[] value, byte[] otherValue, PseudoRando
       return value;
     }
 
+    @Override
+    public boolean hasFixedSize() {
+      return false;
+    }
+
     @Override
     public String toDebugString(Predicate<Debuggable> isInCycle) {
       return "byte[]";

src/main/java/com/code_intelligence/jazzer/mutation/mutator/lang/FloatingPointMutatorFactory.java

@@ -361,6 +361,11 @@ public Float detach(Float value) {
     public String toDebugString(Predicate<Debuggable> isInCycle) {
       return "Float";
     }
+
+    @Override
+    public boolean hasFixedSize() {
+      return true;
+    }
   }
 
   static final class DoubleMutator extends SerializingMutator<Double> {
@@ -623,6 +628,11 @@ private double crossOverMantissa(double value, double otherValue) {
       return Double.longBitsToDouble(bitsWithOtherMantissa);
     }
 
+    @Override
+    public boolean hasFixedSize() {
+      return true;
+    }
+
     @Override
     public Double read(DataInputStream in) throws IOException {
       return forceInRange(in.readDouble(), minValue, maxValue, allowNaN);