Mutate guards on match arms by replacement with true/false

Author: zaneduffield

book/src/mutants.md

@@ -96,3 +96,7 @@ generate unviable cases (e.g. `!1.0`, `-false`).
 
 Entire match arms are deleted in match expressions when a wildcard pattern is present in one of the arms.
 Match expressions without a wildcard pattern would be too prone to unviable mutations of this kind.
+
+## Match arm guards
+
+Match arm guard expressions are replaced with `true` and `false`.

src/mutant.rs

@@ -28,6 +28,8 @@ pub enum Genre {
     UnaryOperator,
     /// Delete match arm.
     MatchArm,
+    /// Replace the expression of a match arm guard with a fixed value.
+    MatchArmGuard,
 }
 
 /// A mutation applied to source code.
@@ -148,6 +150,10 @@ impl Mutant {
                 v.push(s(" with "));
                 v.push(s(self.replacement_text()).yellow());
             }
+            Genre::MatchArmGuard => {
+                v.push(s("replace match guard with "));
+                v.push(s(self.replacement_text()).yellow());
+            }
             Genre::MatchArm => {
                 v.push(s("delete match arm"));
             }

src/visit.rs

@@ -613,15 +613,33 @@ impl<'ast> Visit<'ast> for DiscoveryVisitor<'_> {
         if has_catchall {
             i.arms
                 .iter()
-                // Don't mutate the wild arm, because that will likely be unviable.
-                .filter(|arm| !matches!(arm.pat, syn::Pat::Wild(_)))
+                // Don't mutate the wild arm, because that will likely be unviable, and also
+                // skip it if a guard is present, because the replacement of the guard with 'false'
+                // below is logically equivalent to removing the arm.
+                .filter(|arm| !matches!(arm.pat, syn::Pat::Wild(_)) && arm.guard.is_none())
                 .for_each(|arm| {
                     self.collect_mutant(arm.span().into(), &quote! {}, Genre::MatchArm);
                 });
         } else {
             trace!("match has no `_` pattern");
         }
 
+        i.arms
+            .iter()
+            .flat_map(|arm| &arm.guard)
+            .for_each(|(_if, guard_expr)| {
+                self.collect_mutant(
+                    guard_expr.span().into(),
+                    &quote! { true },
+                    Genre::MatchArmGuard,
+                );
+                self.collect_mutant(
+                    guard_expr.span().into(),
+                    &quote! { false },
+                    Genre::MatchArmGuard,
+                );
+            });
+
         syn::visit::visit_expr_match(self, i);
     }
 }
@@ -1169,4 +1187,36 @@ mod test {
             empty
         );
     }
+
+    #[test]
+    fn mutate_match_guard() {
+        let options = Options::default();
+        let mutants = mutate_source_str(
+            indoc! {"
+                fn main() {
+                    match x {
+                        X::A if foo() => {},
+                        X::A => {},
+                        X::B => {},
+                        X::C if bar() => {},
+                    }
+                }
+            "},
+            &options,
+        )
+        .unwrap();
+        assert_eq!(
+            mutants
+                .iter()
+                .filter(|m| m.genre == Genre::MatchArmGuard)
+                .map(|m| m.name(true))
+                .collect_vec(),
+            [
+                "src/main.rs:3:17: replace match guard with true",
+                "src/main.rs:3:17: replace match guard with false",
+                "src/main.rs:6:17: replace match guard with true",
+                "src/main.rs:6:17: replace match guard with false",
+            ]
+        );
+    }
 }