Add struct field deletion mutations for literals with base expressions (#558)

- [x] Add new Genre variant for struct field deletion mutations
- [x] Implement visit_expr_struct method to detect struct literals with
base (default) expressions
- [x] Generate mutants that delete individual fields from struct
literals with defaults
- [x] Add unit tests in visit.rs to verify struct field deletion
- [x] Update documentation in book and NEWS.md
- [x] Fix trailing comma handling to generate valid Rust code
- [x] Include struct type and function name in mutant descriptions
- [x] Refactor to use MutationTarget enum instead of string parsing

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: Martin Pool <mbp@sourcefrog.net>

Author: Copilot

NEWS.md

@@ -14,6 +14,8 @@
 
 - New: `start_time` and `end_time` fields in `outcomes.json`.
 
+- New: Delete individual fields from struct literals that have a base (default) expression like `..Default::default()` or `..base_value`. This checks that tests verify each field is set correctly and not just relying on default values.
+
 - New: `cargo_mutants_version` field in `outcomes.json`.
 
 - Changed: Functions with attributes whose path ends with `test` are now skipped, not just those with the plain `#[test]` attribute. This means functions with `#[tokio::test]`, `#[sqlx::test]`, and similar testing framework attributes are automatically excluded from mutation testing.

book/src/mutants.md

@@ -119,3 +119,25 @@ Match expressions without a wildcard pattern would be too prone to unviable muta
 ## Match arm guards
 
 Match arm guard expressions are replaced with `true` and `false`.
+
+## Struct literal fields
+
+Individual fields are deleted from struct literals that have a base (default) expression,
+such as `..Default::default()` or `..base_value`.
+
+For example, in this code:
+
+```rust
+let cat = Cat {
+    name: "Felix",
+    coat: Coat::Tuxedo,
+    ..Default::default()
+};
+```
+
+cargo-mutants will generate two mutants: one deleting the `name` field and one deleting
+the `coat` field. This checks that tests verify that each field is set correctly and not
+just relying on the default values.
+
+Struct literals without a base expression are not mutated in this way, because deleting
+a required field would make the code fail to compile.

src/mutant.rs

@@ -31,6 +31,20 @@ pub enum Genre {
     MatchArm,
     /// Replace the expression of a match arm guard with a fixed value.
     MatchArmGuard,
+    /// Delete a field from a struct literal that has a base (default) expression.
+    StructField,
+}
+
+/// The target of a mutation, providing additional context about what is being mutated.
+#[derive(Clone, Eq, PartialEq, Debug)]
+pub enum MutationTarget {
+    /// A field in a struct literal expression.
+    StructLiteralField {
+        /// The name of the field being deleted.
+        field_name: String,
+        /// The name/type of the struct.
+        struct_name: String,
+    },
 }
 
 /// A mutation applied to source code.
@@ -63,6 +77,12 @@ pub struct Mutant {
 
     /// What general category of mutant this is.
     pub genre: Genre,
+
+    /// Additional context about what is being mutated.
+    ///
+    /// This provides structured information about the mutation target, rather than
+    /// encoding it in strings that need to be parsed.
+    pub target: Option<MutationTarget>,
 }
 
 /// The function containing a mutant.
@@ -177,6 +197,22 @@ impl Mutant {
                     .yellow(),
                 );
             }
+            Genre::StructField => {
+                if let Some(MutationTarget::StructLiteralField {
+                    field_name,
+                    struct_name,
+                }) = &self.target
+                {
+                    v.push(s("delete field "));
+                    v.push(s(field_name).yellow());
+                    v.push(s(" from struct "));
+                    v.push(s(struct_name).yellow());
+                    v.push(s(" expression"));
+                } else {
+                    // Fallback: shouldn't happen with proper initialization
+                    v.push(s("delete field from struct expression"));
+                }
+            }
             _ => {
                 if self.replacement.is_empty() {
                     v.push(s("delete "));

src/visit.rs

@@ -24,7 +24,7 @@ use tracing::{debug_span, error, info, trace, trace_span, warn};
 
 use crate::console::WalkProgress;
 use crate::fnvalue::return_type_replacements;
-use crate::mutant::Function;
+use crate::mutant::{Function, MutationTarget};
 use crate::package::Package;
 use crate::pretty::ToPrettyString;
 use crate::source::SourceFile;
@@ -324,6 +324,7 @@ impl DiscoveryVisitor<'_> {
             short_replaced: None,
             replacement: replacement.to_pretty_string(),
             genre,
+            target: None,
         });
     }
 
@@ -661,6 +662,7 @@ impl<'ast> Visit<'ast> for DiscoveryVisitor<'_> {
                     short_replaced,
                     replacement: String::new(),
                     genre: Genre::MatchArm,
+                    target: None,
                 };
                 self.mutants.push(mutant);
             }
@@ -686,6 +688,58 @@ impl<'ast> Visit<'ast> for DiscoveryVisitor<'_> {
 
         syn::visit::visit_expr_match(self, i);
     }
+
+    fn visit_expr_struct(&mut self, i: &'ast syn::ExprStruct) {
+        let _span = trace_span!("struct", line = i.span().start().line).entered();
+        trace!("visit struct expression");
+
+        if attrs_excluded(&i.attrs) {
+            return;
+        }
+
+        // Check if this struct has a base (default) expression like `..Default::default()`
+        if let Some(_rest) = &i.rest {
+            // Get the struct type name
+            let struct_name = i.path.to_pretty_string();
+
+            // Generate a mutant for each field by deleting it
+            // We need to include the trailing comma in the span
+            for pair in i.fields.pairs() {
+                let field = pair.value();
+                if let syn::Member::Named(field_name) = &field.member {
+                    let field_name_str = field_name.to_string();
+                    // Span includes the field and its trailing comma (if present)
+                    let span = if let Some(comma) = pair.punct() {
+                        // Include the comma in the span
+                        let field_span = field.span();
+                        let comma_span = comma.span();
+                        Span {
+                            start: field_span.start().into(),
+                            end: comma_span.end().into(),
+                        }
+                    } else {
+                        // No comma, just the field
+                        field.span().into()
+                    };
+                    let mutant = Mutant {
+                        source_file: self.source_file.clone(),
+                        function: self.fn_stack.last().cloned(),
+                        span,
+                        short_replaced: None,
+                        replacement: String::new(),
+                        genre: Genre::StructField,
+                        target: Some(MutationTarget::StructLiteralField {
+                            field_name: field_name_str,
+                            struct_name: struct_name.clone(),
+                        }),
+                    };
+                    self.mutants.push(mutant);
+                }
+            }
+        }
+
+        syn::visit::visit_expr_struct(self, i);
+    }
 }
 
 // Get the span of the block excluding the braces, or None if it is empty.
@@ -1494,4 +1548,98 @@ mod test {
         assert_eq!(mutate_expr("a >>= b"), &["replace >>= with <<="]);
         assert_eq!(mutate_expr("a <<= b"), &["replace <<= with >>="]);
     }
+
+    #[test]
+    fn delete_struct_field_with_default() {
+        let mutants = mutate_expr(
+            r#"
+            let cat = Cat {
+                name: "Felix", 
+                coat: Coat::Tuxedo,
+                ..Default::default()
+            };
+            "#,
+        );
+        // Should generate mutants to delete each field
+        assert_eq!(
+            mutants,
+            &[
+                "delete field name from struct Cat expression",
+                "delete field coat from struct Cat expression"
+            ]
+        );
+    }
+
+    #[test]
+    fn skip_struct_without_default() {
+        let mutants = mutate_expr(
+            r#"
+            let cat = Cat {
+                name: "Felix", 
+                coat: Coat::Tuxedo,
+            };
+            "#,
+        );
+        // Should not generate any field deletion mutants without a default
+        assert!(mutants.is_empty());
+    }
+
+    #[test]
+    fn delete_struct_field_with_custom_default() {
+        let mutants = mutate_expr(
+            r#"
+            let config = Config {
+                timeout: 30,
+                retries: 5,
+                ..base_config
+            };
+            "#,
+        );
+        // Should work with any base expression, not just Default::default()
+        assert_eq!(
+            mutants,
+            &[
+                "delete field timeout from struct Config expression",
+                "delete field retries from struct Config expression"
+            ]
+        );
+    }
+
+    #[test]
+    fn delete_struct_field_single_field_with_default() {
+        let mutants = mutate_expr(
+            r#"
+            let point = Point {
+                x: 10,
+                ..Default::default()
+            };
+            "#,
+        );
+        // Should work with a single field too
+        assert_eq!(mutants, &["delete field x from struct Point expression"]);
+    }
+
+    #[test]
+    fn delete_struct_field_complex_values() {
+        let mutants = mutate_expr(
+            r#"
+            let settings = Settings {
+                enabled: get_enabled(),
+                count: compute_count() + 10,
+                ..Settings::default()
+            };
+            "#,
+        );
+        // Should work regardless of the complexity of the field values
+        // The visitor also generates mutants for expressions within field values
+        assert_eq!(
+            mutants,
+            &[
+                "delete field enabled from struct Settings expression",
+                "delete field count from struct Settings expression",
+                "replace + with -",
+                "replace + with *"
+            ]
+        );
+    }
 }