Mutate match arms by deletion when _ pattern is present

Author: zaneduffield

src/mutant.rs

@@ -26,6 +26,8 @@ pub enum Genre {
     /// Replace `==` with `!=` and so on.
     BinaryOperator,
     UnaryOperator,
+    /// Delete match arm.
+    MatchArm,
 }
 
 /// A mutation applied to source code.
@@ -131,33 +133,39 @@ impl Mutant {
             style(s.to_string())
         }
         let mut v: Vec<StyledObject<String>> = Vec::new();
-        if self.genre == Genre::FnValue {
-            v.push(s("replace "));
-            let function = self
-                .function
-                .as_ref()
-                .expect("FnValue mutant should have a function");
-            v.push(s(&function.function_name).bright().magenta());
-            if !function.return_type.is_empty() {
-                v.push(s(" "));
-                v.push(s(&function.return_type).magenta());
-            }
-            v.push(s(" with "));
-            v.push(s(self.replacement_text()).yellow());
-        } else {
-            if self.replacement.is_empty() {
-                v.push(s("delete "));
-            } else {
+        match self.genre {
+            Genre::FnValue => {
                 v.push(s("replace "));
-            }
-            v.push(s(self.original_text()).yellow());
-            if !self.replacement.is_empty() {
+                let function = self
+                    .function
+                    .as_ref()
+                    .expect("FnValue mutant should have a function");
+                v.push(s(&function.function_name).bright().magenta());
+                if !function.return_type.is_empty() {
+                    v.push(s(" "));
+                    v.push(s(&function.return_type).magenta());
+                }
                 v.push(s(" with "));
-                v.push(s(&self.replacement).bright().yellow());
+                v.push(s(self.replacement_text()).yellow());
             }
-            if let Some(function) = &self.function {
-                v.push(s(" in "));
-                v.push(s(&function.function_name).bright().magenta());
+            Genre::MatchArm => {
+                v.push(s("delete match arm"));
+            }
+            _ => {
+                if self.replacement.is_empty() {
+                    v.push(s("delete "));
+                } else {
+                    v.push(s("replace "));
+                }
+                v.push(s(self.original_text()).yellow());
+                if !self.replacement.is_empty() {
+                    v.push(s(" with "));
+                    v.push(s(&self.replacement).bright().yellow());
+                }
+                if let Some(function) = &self.function {
+                    v.push(s(" in "));
+                    v.push(s(&function.function_name).bright().magenta());
+                }
             }
         }
         v

src/visit.rs

@@ -595,6 +595,35 @@ impl<'ast> Visit<'ast> for DiscoveryVisitor<'_> {
         };
         syn::visit::visit_expr_unary(self, i);
     }
+
+    fn visit_expr_match(&mut self, i: &'ast syn::ExprMatch) {
+        let _span = trace_span!("match", line = i.span().start().line).entered();
+
+        // While it's not currently possible to annotate expressions with custom attributes, this
+        // limitation could be lifted in the future.
+        if attrs_excluded(&i.attrs) {
+            trace!("match excluded by attrs");
+            return;
+        }
+
+        let has_catchall = i
+            .arms
+            .iter()
+            .any(|arm| matches!(arm.pat, syn::Pat::Wild(_)));
+        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(_)))
+                .for_each(|arm| {
+                    self.collect_mutant(arm.span().into(), &quote! {}, Genre::MatchArm);
+                });
+        } else {
+            trace!("match has no `_` pattern");
+        }
+
+        syn::visit::visit_expr_match(self, i);
+    }
 }
 
 // Get the span of the block excluding the braces, or None if it is empty.
@@ -1084,4 +1113,60 @@ mod test {
             "#}
         );
     }
+
+    #[test]
+    fn mutate_match_arms_with_fallback() {
+        let options = Options::default();
+        let mutants = mutate_source_str(
+            indoc! {"
+                fn main() {
+                    match x {
+                        X::A => {},
+                        X::B => {},
+                        _ => {},
+                    }
+                }
+            "},
+            &options,
+        )
+        .unwrap();
+        assert_eq!(
+            mutants
+                .iter()
+                .filter(|m| m.genre == Genre::MatchArm)
+                .map(|m| m.name(true))
+                .collect_vec(),
+            [
+                "src/main.rs:3:9: delete match arm",
+                "src/main.rs:4:9: delete match arm",
+            ]
+        );
+    }
+
+    #[test]
+    fn skip_match_arms_without_fallback() {
+        let options = Options::default();
+        let mutants = mutate_source_str(
+            indoc! {"
+                fn main() {
+                    match x {
+                        X::A => {},
+                        X::B => {},
+                    }
+                }
+            "},
+            &options,
+        )
+        .unwrap();
+
+        let empty: &[&str] = &[];
+        assert_eq!(
+            mutants
+                .iter()
+                .filter(|m| m.genre == Genre::MatchArm)
+                .map(|m| m.name(true))
+                .collect_vec(),
+            empty
+        );
+    }
 }