Clean up discovery API

Author: sourcefrog

src/lab.rs

@@ -16,7 +16,6 @@ use crate::console::Console;
 use crate::outcome::{LabOutcome, Phase, PhaseResult, ScenarioOutcome};
 use crate::output::OutputDir;
 use crate::process::Process;
-use crate::visit::discover_mutants;
 use crate::*;
 
 /// Run all possible mutation experiments.
@@ -37,7 +36,7 @@ pub fn test_unmutated_then_all_mutants(
     let output_dir = OutputDir::new(output_in_dir)?;
     console.set_debug_log(output_dir.open_debug_log()?);
 
-    let mut mutants = discover_mutants(tool, source_tree, &options)?;
+    let mut mutants = walk_tree(tool, source_tree, &options)?.mutants;
     if options.shuffle {
         fastrand::shuffle(&mut mutants);
     }

src/main.rs

@@ -51,7 +51,7 @@ use crate::path::Utf8PathSlashes;
 use crate::scenario::Scenario;
 use crate::source::SourceFile;
 use crate::tool::Tool;
-use crate::visit::{discover_files, discover_mutants};
+use crate::visit::walk_tree;
 
 const VERSION: &str = env!("CARGO_PKG_VERSION");
 const NAME: &str = env!("CARGO_PKG_NAME");
@@ -217,15 +217,15 @@ fn main() -> Result<()> {
     if args.list_files {
         list_files(&tool, &source_tree_root, &options, args.json)?;
     } else if args.list {
-        let mutants = discover_mutants(&tool, &source_tree_root, &options)?;
+        let discovered = walk_tree(&tool, &source_tree_root, &options)?;
         if args.json {
             if args.diff {
                 eprintln!("--list --diff --json is not (yet) supported");
                 exit(exit_code::USAGE);
             }
-            serde_json::to_writer_pretty(io::BufWriter::new(io::stdout()), &mutants)?;
+            serde_json::to_writer_pretty(io::BufWriter::new(io::stdout()), &discovered.mutants)?;
         } else {
-            console::list_mutants(&mutants, args.diff);
+            console::list_mutants(&discovered.mutants, args.diff);
         }
     } else {
         let lab_outcome =
@@ -236,11 +236,12 @@ fn main() -> Result<()> {
 }
 
 fn list_files(tool: &dyn Tool, source: &Utf8Path, options: &Options, json: bool) -> Result<()> {
-    let files = discover_files(tool, source, options)?;
+    let discovered = walk_tree(tool, source, options)?;
     let mut out = io::BufWriter::new(io::stdout());
     if json {
         let json_list = Value::Array(
-            files
+            discovered
+                .files
                 .iter()
                 .map(|source_file| {
                     json!({
@@ -253,7 +254,7 @@ fn list_files(tool: &dyn Tool, source: &Utf8Path, options: &Options, json: bool)
         );
         serde_json::to_writer_pretty(out, &json_list)?;
     } else {
-        for file in files {
+        for file in discovered.files {
             writeln!(out, "{}", file.tree_relative_path)?;
         }
     }

src/mutate.rs

@@ -263,7 +263,7 @@ mod test {
         let tool = CargoTool::new();
         let source_tree = tool.find_root(tree_path).unwrap();
         let options = Options::default();
-        let mutants = discover_mutants(&tool, &source_tree, &options).unwrap();
+        let mutants = walk_tree(&tool, &source_tree, &options).unwrap().mutants;
         assert_eq!(mutants.len(), 2);
         assert_eq!(
             format!("{:?}", mutants[0]),
@@ -288,7 +288,9 @@ mod test {
         let tree_path = Utf8Path::new("testdata/tree/hang_avoided_by_attr");
         let tool = CargoTool::new();
         let source_tree = tool.find_root(tree_path).unwrap();
-        let mutants = discover_mutants(&tool, &source_tree, &Options::default()).unwrap();
+        let mutants = walk_tree(&tool, &source_tree, &Options::default())
+            .unwrap()
+            .mutants;
         let descriptions = mutants.iter().map(Mutant::describe_change).collect_vec();
         insta::assert_snapshot!(
             descriptions.join("\n"),
@@ -301,7 +303,9 @@ mod test {
         let tree_path = Utf8Path::new("testdata/tree/factorial");
         let tool = CargoTool::new();
         let source_tree = tool.find_root(tree_path).unwrap();
-        let mutants = discover_mutants(&tool, &source_tree, &Options::default()).unwrap();
+        let mutants = walk_tree(&tool, &source_tree, &Options::default())
+            .unwrap()
+            .mutants;
         assert_eq!(mutants.len(), 2);
 
         let mut mutated_code = mutants[0].mutated_code();

src/visit.rs

@@ -23,32 +23,21 @@ use crate::path::TreeRelativePathBuf;
 use crate::source::SourceFile;
 use crate::*;
 
-pub fn discover_mutants(
-    tool: &dyn Tool,
-    root: &Utf8Path,
-    options: &Options,
-) -> Result<Vec<Mutant>> {
-    walk_tree(tool, root, options).map(|x| x.0)
-}
-
-pub fn discover_files(
-    tool: &dyn Tool,
-    root: &Utf8Path,
-    options: &Options,
-) -> Result<Vec<Arc<SourceFile>>> {
-    walk_tree(tool, root, options).map(|x| x.1)
+/// Mutants and files discovered in a source tree.
+///
+/// Files are listed separately so that we can represent files that
+/// were visited but that produced no mutants.
+pub struct Discovered {
+    pub mutants: Vec<Mutant>,
+    pub files: Vec<Arc<SourceFile>>,
 }
 
 /// Discover all mutants and all source files.
 ///
 /// The list of source files includes even those with no mutants.
-fn walk_tree(
-    tool: &dyn Tool,
-    root: &Utf8Path,
-    options: &Options,
-) -> Result<(Vec<Mutant>, Vec<Arc<SourceFile>>)> {
+pub fn walk_tree(tool: &dyn Tool, root: &Utf8Path, options: &Options) -> Result<Discovered> {
     let mut mutants = Vec::new();
-    let mut seen_files: Vec<Arc<SourceFile>> = Vec::new();
+    let mut files: Vec<Arc<SourceFile>> = Vec::new();
 
     let mut file_queue: VecDeque<Arc<SourceFile>> = tool.root_files(root)?.into();
     while let Some(source_file) = file_queue.pop_front() {
@@ -86,9 +75,9 @@ fn walk_tree(
             }
         }
         mutants.append(&mut file_mutants);
-        seen_files.push(Arc::clone(&source_file));
+        files.push(Arc::clone(&source_file));
     }
-    Ok((mutants, seen_files))
+    Ok(Discovered { mutants, files })
 }
 
 /// Find all possible mutants in a source file.