mutate delayed execution code stored in statics

We don't want to mutate code executed only during static initialization.
Unfortunately the current filtering also picks up code that is executed
after static initialization as lambdas.

This change implelements an imperfect comprimise where code stored as
Suppliers, Functions etc will be considered for mutation.

This will fail to mutate delayed execution code stored in other types,
and will incorrectly mutate code that is executed only during
initialization if it is within a method that returns a Supplier etc.

Although imperfect, it is an improvement.

pitest-entry/src/main/java/org/pitest/mutationtest/build/intercept/staticinitializers/StaticInitializerInterceptor.java

@@ -1,6 +1,9 @@
 package org.pitest.mutationtest.build.intercept.staticinitializers;
 
 import org.objectweb.asm.Handle;
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.tree.AbstractInsnNode;
+import org.objectweb.asm.tree.FieldInsnNode;
 import org.objectweb.asm.tree.InvokeDynamicInsnNode;
 import org.objectweb.asm.tree.MethodInsnNode;
 import org.pitest.bytecode.analysis.ClassTree;
@@ -11,20 +14,36 @@
 import org.pitest.mutationtest.engine.Location;
 import org.pitest.mutationtest.engine.Mutater;
 import org.pitest.mutationtest.engine.MutationDetails;
+import org.pitest.sequence.Context;
+import org.pitest.sequence.Match;
+import org.pitest.sequence.QueryParams;
+import org.pitest.sequence.QueryStart;
+import org.pitest.sequence.SequenceMatcher;
+import org.pitest.sequence.SequenceQuery;
+import org.pitest.sequence.Slot;
+import org.pitest.sequence.SlotWrite;
 
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
 import java.util.Optional;
 import java.util.Set;
 import java.util.function.Function;
 import java.util.function.Predicate;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
+import static org.pitest.bytecode.analysis.InstructionMatchers.anyInstruction;
+import static org.pitest.bytecode.analysis.InstructionMatchers.isA;
+import static org.pitest.bytecode.analysis.InstructionMatchers.methodCallNamed;
+import static org.pitest.bytecode.analysis.InstructionMatchers.notAnInstruction;
+import static org.pitest.bytecode.analysis.OpcodeMatchers.PUTSTATIC;
+import static org.pitest.sequence.Result.result;
+
 /**
  * Identifies and marks mutations in code that is active during class
  * Initialisation.
@@ -39,6 +58,29 @@
  */
 class StaticInitializerInterceptor implements MutationInterceptor {
 
+  static final Slot<AbstractInsnNode> START = Slot.create(AbstractInsnNode.class);
+
+  static final SequenceMatcher<AbstractInsnNode> DELAYED_EXECUTION = QueryStart
+          .any(AbstractInsnNode.class)
+          .then(returnsDeferredExecutionCode().or(isA(InvokeDynamicInsnNode.class)).and(store(START.write())))
+          .then(enumConstructorCallAndStore().or(QueryStart.match(PUTSTATIC)))
+          .zeroOrMore(QueryStart.match(anyInstruction()))
+          .compile(QueryParams.params(AbstractInsnNode.class)
+                  .withIgnores(notAnInstruction())
+          );
+
+  private static Match<AbstractInsnNode> returnsDeferredExecutionCode() {
+    return (c,n) -> result(n.getOpcode() == Opcodes.INVOKESTATIC && returnDelayedExecutionType(((MethodInsnNode) n).desc), c);
+  }
+
+  private static boolean returnDelayedExecutionType(String desc) {
+    int endOfParams = desc.indexOf(')');
+    return endOfParams <= 0 || desc.substring(endOfParams + 1).startsWith("Ljava/util/function/");
+  }
+
+  private static SequenceQuery<AbstractInsnNode> enumConstructorCallAndStore() {
+    return QueryStart.match(methodCallNamed("<init>")).then(PUTSTATIC);
+  }
   private Predicate<MutationDetails> isStaticInitCode;
 
   @Override
@@ -73,28 +115,54 @@ private void analyseClass(ClassTree tree) {
               .map(MethodTree::asLocation)
               .collect(Collectors.toSet());
 
+      Set<Call> storedToSupplier = findsCallsStoredToSuppliers(tree);
+
       // Get map of each private method to the private methods it calls
-      // Any call to a no private method breaks the chain
+      // Any call to a non private method breaks the chain
       Map<Location, List<Call>> callTree = tree.methods().stream()
               .filter(m -> m.isPrivate() || m.rawNode().name.equals("<clinit>"))
               .flatMap(m -> allCallsFor(tree, m).stream().map(c -> new Call(m.asLocation(), c)))
               .filter(c -> privateMethods.contains(c.to()))
+              .filter(c -> !storedToSupplier.contains(c))
               .collect(Collectors.groupingBy(Call::from));
 
-      Set<Location> visited = new HashSet<>();
 
-      visit(callTree, visited, clinit.get().asLocation());
+      Set<Location> calledOnlyFromStaticInitializer = new HashSet<>();
 
-      this.isStaticInitCode = m -> visited.contains(m.getId().getLocation());
+      visit(callTree, calledOnlyFromStaticInitializer, clinit.get().asLocation());
+
+      this.isStaticInitCode = m -> calledOnlyFromStaticInitializer.contains(m.getId().getLocation());
     }
   }
 
+  private Set<Call> findsCallsStoredToSuppliers(ClassTree tree) {
+     Set<Call> all = new HashSet<>(directClinitCallsToDelayedExecutionCode(tree));
+     all.addAll(storedViaEnumConstructor());
+     return all;
+  }
+
+  private Set<Call> storedViaEnumConstructor() {
+return Collections.emptySet();
+  }
+
+  private Set<Call> directClinitCallsToDelayedExecutionCode(ClassTree tree) {
+    return tree.methods().stream()
+            .filter(m -> m.isPrivate() || m.rawNode().name.equals("<clinit>"))
+            .flatMap(m -> delayedExecutionCall(m).stream().map(c -> new Call(m.asLocation(), c)))
+            .collect(Collectors.toSet());
+  }
+
+  private List<Location> delayedExecutionCall(MethodTree method) {
+    Context context = Context.start();
+    return DELAYED_EXECUTION.contextMatches(method.instructions(), context).stream()
+            .map(c -> c.retrieve(START.read()).get())
+            .flatMap(this::nodeToLocation)
+            .collect(Collectors.toList());
+  }
+
   private List<Location> allCallsFor(ClassTree tree, MethodTree m) {
-    // temporarily disable dynamic calls as they are more likely to be involved
-    // in storing delayed execution code within static fields.
-    return callsFor(tree,m).collect(Collectors.toList());
-  //  return Stream.concat(callsFor(tree,m), invokeDynamicCallsFor(tree,m))
-  //          .collect(Collectors.toList());
+    return Stream.concat(callsFor(tree,m), invokeDynamicCallsFor(tree,m))
+            .collect(Collectors.toList());
   }
 
   private Stream<Location> callsFor(ClassTree tree, MethodTree m) {
@@ -123,6 +191,18 @@ private void visit(Map<Location, List<Call>> callTree, Set<Location> visited, Lo
     }
   }
 
+  private Stream<Location> nodeToLocation(AbstractInsnNode n) {
+    if (n instanceof MethodInsnNode) {
+      return Stream.of(asLocation((MethodInsnNode) n));
+    }
+
+    if (n instanceof InvokeDynamicInsnNode) {
+      return asLocation((InvokeDynamicInsnNode) n);
+    }
+
+    return Stream.empty();
+  }
+
   private Location asLocation(MethodInsnNode call) {
     return Location.location(ClassName.fromString(call.owner), call.name, call.desc);
   }
@@ -166,6 +246,10 @@ public InterceptorType type() {
     return InterceptorType.FILTER;
   }
 
+  private static Match<AbstractInsnNode> store(SlotWrite<AbstractInsnNode> slot) {
+    return (c, n) -> result(true, c.store(slot, n));
+  }
+
 }
 
 class Call {
@@ -184,4 +268,21 @@ Location from() {
   Location to() {
     return to;
   }
+
+  @Override
+  public boolean equals(Object o) {
+    if (this == o) {
+      return true;
+    }
+    if (o == null || getClass() != o.getClass()) {
+      return false;
+    }
+    Call call = (Call) o;
+    return Objects.equals(from, call.from) && Objects.equals(to, call.to);
+  }
+
+  @Override
+  public int hashCode() {
+    return Objects.hash(from, to);
+  }
 }

pitest-entry/src/test/java/com/example/staticinitializers/EnumFieldSupplier.java

@@ -0,0 +1,20 @@
+package com.example.staticinitializers;
+
+import java.util.function.Supplier;
+
+public enum EnumFieldSupplier {
+    A(canMutate());
+
+    private final Supplier<String> supplier;
+
+    EnumFieldSupplier(Supplier<String> supplier) {
+        this.supplier = supplier;
+    }
+
+    private static Supplier<String> canMutate() {
+        // don't mutate
+        System.out.println("ideally would mutate me");
+
+        return () -> "Do not mutate"; // mutate
+    }
+}

pitest-entry/src/test/java/com/example/staticinitializers/StaticFunctionField.java

@@ -0,0 +1,14 @@
+package com.example.staticinitializers;
+
+import java.util.function.Function;
+
+public class StaticFunctionField {
+    private static final Function<String,String> FOO = canMutate();
+
+    private static Function<String, String> canMutate() {
+        // don't mutate
+        System.out.println("ideally would mutate me");
+
+        return s -> s + "foo";
+    }
+}

pitest-entry/src/test/java/com/example/staticinitializers/StaticSupplierField.java

@@ -0,0 +1,14 @@
+package com.example.staticinitializers;
+
+import java.util.function.Supplier;
+
+public class StaticSupplierField {
+    final static Supplier<String> SUPPLER = canMutate();
+
+    private static Supplier<String> canMutate() {
+        // don't mutate
+        System.out.println("ideally would mutate me");
+
+        return () -> "Do not mutate"; // mutate
+    }
+}

pitest-entry/src/test/java/org/pitest/mutationtest/build/intercept/staticinitializers/StaticInitializerInterceptorTest.java

@@ -1,11 +1,14 @@
 package org.pitest.mutationtest.build.intercept.staticinitializers;
 
 import com.example.staticinitializers.BrokenChain;
+import com.example.staticinitializers.EnumFieldSupplier;
 import com.example.staticinitializers.EnumWithLambdaInConstructor;
 import com.example.staticinitializers.MethodsCallsEachOtherInLoop;
 import com.example.staticinitializers.NestedEnumWithLambdaInStaticInitializer;
 import com.example.staticinitializers.SecondLevelPrivateMethods;
 import com.example.staticinitializers.SingletonWithWorkInInitializer;
+import com.example.staticinitializers.StaticFunctionField;
+import com.example.staticinitializers.StaticSupplierField;
 import com.example.staticinitializers.ThirdLevelPrivateMethods;
 import org.junit.Ignore;
 import org.junit.Test;
@@ -146,7 +149,6 @@ public void analysisDoesNotGetStuckInInfiniteLoop() {
     }
 
     @Test
-    @Ignore("temporally disabled while filtering reworked")
     public void filtersMutantsInEnumPrivateMethodsCalledViaMethodRef() {
         v.forClass(EnumWithLambdaInConstructor.class)
                 .forMutantsMatching(inMethodStartingWith("doStuff"))
@@ -156,7 +158,6 @@ public void filtersMutantsInEnumPrivateMethodsCalledViaMethodRef() {
     }
 
     @Test
-    @Ignore("temporally disabled while filtering reworked")
     public void filtersMutantsInLambdaCalledFromStaticInitializerInNestedEnum() {
         v.forClass(NestedEnumWithLambdaInStaticInitializer.TOYS.class)
                 .forMutantsMatching(inMethodStartingWith("lambda"))
@@ -165,6 +166,36 @@ public void filtersMutantsInLambdaCalledFromStaticInitializerInNestedEnum() {
                 .verify();
     }
 
+    @Test
+    public void doesNotSuppressDownStreamMutationsForCodeStoredInSuppliers() {
+        v.forClass(StaticSupplierField.class)
+                .forMethod("canMutate")
+                .forAnyCode()
+                .mutantsAreGenerated()
+                .noMutantsAreFiltered()
+                .verify();
+    }
+
+    @Test
+    public void doesNotSuppressDownStreamMutationsForCodeStoredInFunctions() {
+        v.forClass(StaticFunctionField.class)
+                .forMethod("canMutate")
+                .forAnyCode()
+                .mutantsAreGenerated()
+                .noMutantsAreFiltered()
+                .verify();
+    }
+
+    @Test
+    public void doesNotSuppressDownStreamMutationsForEnumFieldSuppliers() {
+        v.forClass(EnumFieldSupplier.class)
+                .forMethod("canMutate")
+                .forAnyCode()
+                .mutantsAreGenerated()
+                .noMutantsAreFiltered()
+                .verify();
+    }
+
     private Predicate<MutationDetails> inMethod(String name, String desc) {
         return m -> m.getMethod().equals(name) && m.getId().getLocation().getMethodDesc().equals(desc);
     }