Refactor mutant name computation into constructor

Author: 0xLoopTheory

src/mutant.rs

@@ -109,6 +109,34 @@ pub struct Function {
 }
 
 impl Mutant {
+    /// Construct a mutant discovered while walking source code.
+    ///
+    /// This initializes all fields and precomputes the human-readable `name`
+    /// (including file path, line/column, and change description) for use in
+    /// CLI output, filtering, and JSON.
+    pub(crate) fn new_discovered(
+        source_file: SourceFile,
+        function: Option<Arc<Function>>,
+        span: Span,
+        short_replaced: Option<String>,
+        replacement: String,
+        genre: Genre,
+        target: Option<MutationTarget>,
+    ) -> Self {
+        let mut mutant = Mutant {
+            name: String::new(),
+            source_file,
+            function,
+            span,
+            short_replaced,
+            replacement,
+            genre,
+            target,
+        };
+        mutant.name = mutant.name(true);
+        mutant
+    }
+
     /// Return text of the whole file with the mutation applied.
     pub fn mutated_code(&self) -> String {
         self.span.replace(

src/visit.rs

@@ -75,10 +75,6 @@ pub fn walk_tree(
         files.append(&mut package_files);
     }
 
-    for mutant in &mut mutants {
-        mutant.name = mutant.name(true);
-    }
-
     progress.finish();
     Ok(Discovered { mutants, files })
 }
@@ -322,16 +318,16 @@ impl DiscoveryVisitor<'_> {
 
     /// Record that we generated some mutants.
     fn collect_mutant(&mut self, span: Span, replacement: &TokenStream, genre: Genre) {
-        self.mutants.push(Mutant {
-            name: String::new(),
-            source_file: self.source_file.clone(),
-            function: self.fn_stack.last().cloned(),
+        let mutant = Mutant::new_discovered(
+            self.source_file.clone(),
+            self.fn_stack.last().cloned(),
             span,
-            short_replaced: None,
-            replacement: replacement.to_pretty_string(),
+            None,
+            replacement.to_pretty_string(),
             genre,
-            target: None,
-        });
+            None,
+        );
+        self.mutants.push(mutant);
     }
 
     fn collect_fn_mutants(&mut self, sig: &Signature, block: &Block) {
@@ -661,16 +657,15 @@ impl<'ast> Visit<'ast> for DiscoveryVisitor<'_> {
                     continue;
                 }
                 let short_replaced = Some(arm.pat.to_pretty_string());
-                let mutant = Mutant {
-                    name: String::new(),
-                    source_file: self.source_file.clone(),
-                    function: self.fn_stack.last().cloned(),
-                    span: arm.span().into(),
+                let mutant = Mutant::new_discovered(
+                    self.source_file.clone(),
+                    self.fn_stack.last().cloned(),
+                    arm.span().into(),
                     short_replaced,
-                    replacement: String::new(),
-                    genre: Genre::MatchArm,
-                    target: None,
-                };
+                    String::new(),
+                    Genre::MatchArm,
+                    None,
+                );
                 self.mutants.push(mutant);
             }
         } else {
@@ -728,19 +723,18 @@ impl<'ast> Visit<'ast> for DiscoveryVisitor<'_> {
                         // No comma, just the field
                         field.span().into()
                     };
-                    let mutant = Mutant {
-                        name: String::new(),
-                        source_file: self.source_file.clone(),
-                        function: self.fn_stack.last().cloned(),
+                    let mutant = Mutant::new_discovered(
+                        self.source_file.clone(),
+                        self.fn_stack.last().cloned(),
                         span,
-                        short_replaced: None,
-                        replacement: String::new(),
-                        genre: Genre::StructField,
-                        target: Some(MutationTarget::StructLiteralField {
+                        None,
+                        String::new(),
+                        Genre::StructField,
+                        Some(MutationTarget::StructLiteralField {
                             field_name: field_name_str,
                             struct_name: struct_name.clone(),
                         }),
-                    };
+                    );
                     self.mutants.push(mutant);
                 }
             }