style: clear the pre-existing clippy warnings

`cargo clippy --all-targets -- -D warnings` now passes. Mechanical, with no
behaviour change:

  - four `match check_version_constraints(..) { Ok(v) => info!(..), Err(e) =>
    return Err(e) }` blocks collapsed to `?` plus the log line
  - redundant `&` in format!/bail!/panic!/assert! arguments
  - `for (_k, v) in map.iter()` -> `map.values()`
  - `sort_by(|a, b| a.step.cmp(&b.step))` -> `sort_by_key(|c| c.step)`; both
    are stable sorts on the same key
  - a needless borrow at the af_anndata call site

The one exception is `mutable_key_type` in jrsonnet_main, which fires on the
map returned by jrsonnet's `tla_opts()`. The key type is theirs, not ours, and
nothing here mutates a key, so that one is allowed with a note rather than
worked around.

Note for anyone doing this in bulk: `&x` is only redundant inside format-like
macros. Removing it blindly turns `chem_hm.get(&name)` into a type error and
`.args(&args)` into a move, both of which surfaced here and are restored.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01VhyNvEWUgY8ALVacdJHxVJ

Author: rob-p

src/atac/index.rs

@@ -17,14 +17,12 @@ pub(crate) fn piscem_index(af_home_path: &Path, opts: &IndexOpts) -> anyhow::Res
         .as_ref()
         .context("piscem program info is missing; please run `simpleaf set-paths`.")?;
 
-    match prog_utils::check_version_constraints(
+    let af_ver = prog_utils::check_version_constraints(
         "piscem",
         prog_utils::min_versions::PISCEM,
         &piscem_prog_info.version,
-    ) {
-        Ok(af_ver) => info!("found piscem version {:#}, proceeding", af_ver),
-        Err(e) => return Err(e),
-    }
+    )?;
+    info!("found piscem version {:#}, proceeding", af_ver);
 
     let output = opts.output.clone();
     let output_index_dir = output.join("index");

src/atac/process.rs

@@ -167,28 +167,24 @@ pub(crate) fn check_progs<P: AsRef<Path>>(
         .as_ref()
         .context("alevin-fry program info is missing; please run `simpleaf set-paths`.")?;
 
-    match prog_utils::check_version_constraints(
+    let af_ver = prog_utils::check_version_constraints(
         "alevin-fry",
         prog_utils::min_versions::ALEVIN_FRY,
         &af_prog_info.version,
-    ) {
-        Ok(af_ver) => info!("found alevin-fry version {:#}, proceeding", af_ver),
-        Err(e) => return Err(e),
-    }
+    )?;
+    info!("found alevin-fry version {:#}, proceeding", af_ver);
 
     let piscem_prog_info = rp
         .piscem
         .as_ref()
         .context("piscem program info is missing; please run `simpleaf set-paths`.")?;
 
-    match prog_utils::check_version_constraints(
+    let piscem_ver = prog_utils::check_version_constraints(
         "piscem",
         prog_utils::min_versions::PISCEM,
         &piscem_prog_info.version,
-    ) {
-        Ok(piscem_ver) => info!("found piscem version {:#}, proceeding", piscem_ver),
-        Err(e) => return Err(e),
-    }
+    )?;
+    info!("found piscem version {:#}, proceeding", piscem_ver);
 
     if opts.call_peaks {
         let macs_prog_info = rp
@@ -197,14 +193,12 @@ pub(crate) fn check_progs<P: AsRef<Path>>(
             .context(
                 "macs3 program info is missing; please run `simpleaf set-paths` before using `--call-peaks`.",
             )?;
-        match prog_utils::check_version_constraints(
+        let macs_ver = prog_utils::check_version_constraints(
             "macs3",
             prog_utils::min_versions::MACS3,
             &macs_prog_info.version,
-        ) {
-            Ok(macs_ver) => info!("found macs3 version {:#}, proceeding", macs_ver),
-            Err(e) => return Err(e),
-        }
+        )?;
+        info!("found macs3 version {:#}, proceeding", macs_ver);
     }
 
     Ok(())
@@ -225,7 +219,7 @@ pub(crate) fn map_reads(af_home_path: &Path, opts: &ProcessOpts) -> anyhow::Resu
 
     // using a piscem index
     let mut piscem_map_cmd =
-        std::process::Command::new(format!("{}", &piscem_prog_info.exe_path.display()));
+        std::process::Command::new(format!("{}", piscem_prog_info.exe_path.display()));
     let index_path = format!("{}", index_base.display());
     piscem_map_cmd
         .arg("map-sc-atac")
@@ -305,8 +299,7 @@ fn macs_call_peaks(af_home_path: &Path, opts: &ProcessOpts) -> anyhow::Result<Ma
     let bedsuf = if opts.compress { ".bed.gz" } else { ".bed" };
     let bed_input = gpl_dir.join(format!("map{}", bedsuf));
     let peaks_output = gpl_dir.join("macs");
-    let mut macs_cmd =
-        std::process::Command::new(format!("{}", &macs_prog_info.exe_path.display()));
+    let mut macs_cmd = std::process::Command::new(format!("{}", macs_prog_info.exe_path.display()));
     macs_cmd
         .arg("callpeak")
         .arg("-f")
@@ -387,7 +380,7 @@ fn af_sort(af_home_path: &Path, opts: &ProcessOpts) -> anyhow::Result<SortStageO
 
     let gpl_dir = opts.output.join("af_process");
     let rad_dir = opts.output.join("af_map");
-    let mut af_sort = std::process::Command::new(format!("{}", &af_prog_info.exe_path.display()));
+    let mut af_sort = std::process::Command::new(format!("{}", af_prog_info.exe_path.display()));
     af_sort
         .arg("atac")
         .arg("sort")
@@ -559,7 +552,7 @@ fn af_gpl(af_home_path: &Path, opts: &ProcessOpts) -> anyhow::Result<GplStageOut
     };
 
     let map_file = opts.output.join("af_map");
-    let mut af_gpl = std::process::Command::new(format!("{}", &af_prog_info.exe_path.display()));
+    let mut af_gpl = std::process::Command::new(format!("{}", af_prog_info.exe_path.display()));
     af_gpl
         .arg("atac")
         .arg("generate-permit-list")

src/simpleaf_commands/chemistry.rs

@@ -159,7 +159,7 @@ fn get_chem_def_from_json(
         } else {
             bail!(
                 "Could not find chemistry definition for {} from the requested JSON {}",
-                &add_opts.name,
+                add_opts.name,
                 json_src
             );
         }
@@ -172,7 +172,7 @@ fn get_chem_def_from_json(
         } else {
             bail!(
                 "Could not properly parse the chemistry {} from the requested source JSON {}",
-                &add_opts.name,
+                add_opts.name,
                 json_src
             );
         }

src/simpleaf_commands/multiplex_quant.rs

@@ -532,7 +532,7 @@ pub fn multiplex_map_and_quant(af_home: &Path, opts: MultiplexQuantOpts) -> anyh
         let opath = anndata_path
             .as_ref()
             .expect("anndata_path must exist when --anndata-out is set");
-        af_anndata::convert_csr_to_anndata(&quant_output, &opath)?;
+        af_anndata::convert_csr_to_anndata(&quant_output, opath)?;
         convert_duration_secs = Some(convert_start.elapsed().as_secs_f64());
     }
 

src/simpleaf_commands/quant.rs

@@ -410,7 +410,7 @@ fn run_mapping_stage(
                         "A piscem index is being used, but piscem program info is missing.",
                     )?;
                 let mut piscem_quant_cmd =
-                    std::process::Command::new(format!("{}", &piscem_prog_info.exe_path.display()));
+                    std::process::Command::new(format!("{}", piscem_prog_info.exe_path.display()));
                 let index_path = format!("{}", index_base.display());
                 piscem_quant_cmd
                     .arg("map-sc")
@@ -514,7 +514,7 @@ fn run_quant_stage(
         .context("Alevin-fry program info is missing; please run `simpleaf set-paths`.")?
         .exe_path
         .clone();
-    let mut alevin_gpl_cmd = std::process::Command::new(format!("{}", &alevin_fry.display()));
+    let mut alevin_gpl_cmd = std::process::Command::new(format!("{}", alevin_fry.display()));
     let gpl_threads = setup.threads.min(8);
     alevin_gpl_cmd.arg("generate-permit-list");
     alevin_gpl_cmd.arg("-i").arg(&mapping.map_output);
@@ -530,7 +530,7 @@ fn run_quant_stage(
     exec::run_checked(&mut alevin_gpl_cmd, "[generate permit list]")?;
     let gpl_duration = gpl_start.elapsed();
 
-    let mut alevin_collate_cmd = std::process::Command::new(format!("{}", &alevin_fry.display()));
+    let mut alevin_collate_cmd = std::process::Command::new(format!("{}", alevin_fry.display()));
     alevin_collate_cmd.arg("collate");
     alevin_collate_cmd.arg("-i").arg(&gpl_output);
     alevin_collate_cmd.arg("-r").arg(&mapping.map_output);
@@ -545,7 +545,7 @@ fn run_quant_stage(
     exec::run_checked(&mut alevin_collate_cmd, "[collate]")?;
     let collate_duration = collate_start.elapsed();
 
-    let mut alevin_quant_cmd = std::process::Command::new(format!("{}", &alevin_fry.display()));
+    let mut alevin_quant_cmd = std::process::Command::new(format!("{}", alevin_fry.display()));
     alevin_quant_cmd
         .arg("quant")
         .arg("-i")

src/utils/jrsonnet_main.rs

@@ -210,6 +210,10 @@ fn main_catch(opts: Opts) -> anyhow::Result<String> {
     }
 }
 
+// `tla_opts()` hands back a jrsonnet map whose key type carries interior
+// mutability. The key is never mutated here -- and the type is jrsonnet's,
+// not ours to change -- so the lint has nothing to catch.
+#[allow(clippy::mutable_key_type)]
 fn main_real(opts: Opts) -> Result<String, Error> {
     let _gc_leak_guard = opts.gc.leak_on_exit();
     let _gc_print_stats = opts.gc.stats_printer();

src/utils/workflow_utils.rs

@@ -196,7 +196,7 @@ be certain you intend to do this.",
     // remain that we have not seen, print out the appropriate
     // warning (or error) message. If the message is an error, then
     // bail after issuing it.
-    for (_cn, action) in expected_columns.iter() {
+    for action in expected_columns.values() {
         match action {
             HeaderFieldAction::Recommended(msg) => {
                 warn!("{}", msg);
@@ -780,7 +780,7 @@ impl SimpleafWorkflow {
         )?;
 
         // sort the cmd queue by its `step`.
-        cmd_queue.sort_by(|cmd1, cmd2| cmd1.step.cmp(&cmd2.step));
+        cmd_queue.sort_by_key(|cmd| cmd.step);
 
         Ok(SimpleafWorkflow {
             af_home_path: af_home_path.as_ref().to_owned(),
@@ -1448,7 +1448,7 @@ pub fn parse_manifest<T: AsRef<Path>>(manifest_path: &T) -> anyhow::Result<serde
     // Open the file in read-only mode with buffer.
     let manifest_path = manifest_path.as_ref();
     let file = File::open(manifest_path)
-        .with_context(|| format!("couldn't open manifest path {}", &manifest_path.display()))?;
+        .with_context(|| format!("couldn't open manifest path {}", manifest_path.display()))?;
     let reader = BufReader::new(file);
     let manifest = serde_json::from_reader(reader)?;
     Ok(manifest)
@@ -1836,7 +1836,7 @@ mod tests {
         } else {
             panic!(
                 "Expected {:?} to match WFCommand::ExternalCommand, but it didn't",
-                &cmd.cmd
+                cmd.cmd
             );
         }
 

tests/cli_help_snapshots.rs

@@ -115,7 +115,7 @@ fn cli_help_outputs_match_snapshots() {
         assert!(
             output.status.success(),
             "expected success for args {:?}, got status {:?}\nstderr:\n{}",
-            &args,
+            args,
             output.status.code(),
             String::from_utf8_lossy(&output.stderr)
         );
@@ -139,7 +139,7 @@ fn cli_help_outputs_match_snapshots() {
             "help output drifted for args {:?} against snapshot {}.\n\
              If this change is intended, regenerate with:\n    \
              UPDATE_CLI_SNAPSHOTS=1 cargo test --test cli_help_snapshots",
-            &args, snapshot_file
+            args, snapshot_file
         );
     }