make clippy happy

.github/workflows/rust.yml

@@ -18,7 +18,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v2.6.0
+        uses: actions/checkout@v3
 
       - name: Install stable toolchain
         uses: dtolnay/rust-toolchain@stable
@@ -36,7 +36,7 @@ jobs:
         os: [ubuntu-latest, macos-latest]
     runs-on: ${{ matrix.os }}
     steps:
-    - uses: actions/checkout@v2.6.0
+    - uses: actions/checkout@v3
     - name: Build
       run: cargo build --verbose
     - name: Run tests
@@ -50,7 +50,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v2.6.0
+        uses: actions/checkout@v3
 
       - name: Install stable toolchain
         uses: dtolnay/rust-toolchain@stable
@@ -70,7 +70,7 @@ jobs:
         os: [ubuntu-latest, macos-latest]
     runs-on: ${{ matrix.os }}
     steps:
-    - uses: actions/checkout@v2.6.0
+    - uses: actions/checkout@v3
     - name: Install
       run: cargo build --release
     - name: sample run

src/cellfilter.rs

@@ -234,7 +234,7 @@ fn process_unfiltered(
     gpl_opts: &GenPermitListOpts,
 ) -> anyhow::Result<u64> {
     let parent = std::path::Path::new(output_dir);
-    std::fs::create_dir_all(&parent)
+    std::fs::create_dir_all(parent)
         .with_context(|| format!("couldn't create directory path {}", parent.display()))?;
 
     // the smallest number of reads we'll allow per barcode
@@ -374,7 +374,7 @@ fn process_unfiltered(
     );
 
     let parent = std::path::Path::new(output_dir);
-    std::fs::create_dir_all(&parent).with_context(|| {
+    std::fs::create_dir_all(parent).with_context(|| {
         format!(
             "couldn't create path to output directory {}",
             parent.display()
@@ -409,7 +409,7 @@ fn process_unfiltered(
 
     let pm_path = parent.join("permit_map.bin");
     let pm_file =
-        std::fs::File::create(&pm_path).context("could not create serialization file.")?;
+        std::fs::File::create(pm_path).context("could not create serialization file.")?;
     let mut pm_writer = BufWriter::new(&pm_file);
     bincode::serialize_into(&mut pm_writer, &hm)
         .context("couldn't serialize permit list mapping.")?;
@@ -425,7 +425,7 @@ fn process_unfiltered(
     });
 
     let m_path = parent.join("generate_permit_list.json");
-    let mut m_file = std::fs::File::create(&m_path).context("could not create metadata file.")?;
+    let mut m_file = std::fs::File::create(m_path).context("could not create metadata file.")?;
 
     let meta_info_string =
         serde_json::to_string_pretty(&meta_info).context("could not format json.")?;
@@ -525,7 +525,7 @@ fn process_filtered(
     }
 
     let parent = std::path::Path::new(output_dir);
-    std::fs::create_dir_all(&parent).with_context(|| {
+    std::fs::create_dir_all(parent).with_context(|| {
         format!(
             "failed to create path to output location {}",
             parent.display()
@@ -550,7 +550,7 @@ fn process_filtered(
     };
 
     let s_path = parent.join("permit_map.bin");
-    let s_file = std::fs::File::create(&s_path).context("could not create serialization file.")?;
+    let s_file = std::fs::File::create(s_path).context("could not create serialization file.")?;
     let mut s_writer = BufWriter::new(&s_file);
     bincode::serialize_into(&mut s_writer, &full_permit_list)
         .context("couldn't serialize permit list.")?;
@@ -566,7 +566,7 @@ fn process_filtered(
     });
 
     let m_path = parent.join("generate_permit_list.json");
-    let mut m_file = std::fs::File::create(&m_path).context("could not create metadata file.")?;
+    let mut m_file = std::fs::File::create(m_path).context("could not create metadata file.")?;
 
     let meta_info_string =
         serde_json::to_string_pretty(&meta_info).context("could not format json.")?;

src/collate.rs

@@ -217,7 +217,7 @@ fn correct_unmapped_counts(
     unmapped_file: &std::path::Path,
     parent: &std::path::Path,
 ) {
-    let i_file = File::open(&unmapped_file).unwrap();
+    let i_file = File::open(unmapped_file).unwrap();
     let mut br = BufReader::new(i_file);
 
     // enough to hold a key value pair (a u64 key and u32 value)
@@ -244,7 +244,7 @@ fn correct_unmapped_counts(
     }
 
     let s_path = parent.join("unmapped_bc_count_collated.bin");
-    let s_file = std::fs::File::create(&s_path).expect("could not create serialization file.");
+    let s_file = std::fs::File::create(s_path).expect("could not create serialization file.");
     let mut s_writer = BufWriter::new(&s_file);
     bincode::serialize_into(&mut s_writer, &unmapped_count)
         .expect("couldn't serialize corrected unmapped bc count.");

src/convert.rs

@@ -99,7 +99,7 @@ where
 {
     let oname = Path::new(rad_file.as_ref());
     let parent = oname.parent().unwrap();
-    std::fs::create_dir_all(&parent).unwrap();
+    std::fs::create_dir_all(parent).unwrap();
 
     if oname.exists() {
         std::fs::remove_file(oname).expect("could not be deleted");

src/em.rs

@@ -136,7 +136,7 @@ pub(crate) fn em_update_subset(
                 }
             }
         } else {
-            let tidx = labels.get(0).expect("can't extract labels");
+            let tidx = labels.first().expect("can't extract labels");
             alphas_out[*tidx as usize] += *count as f32;
         }
     }
@@ -167,7 +167,7 @@ pub(crate) fn em_update_subset_usa(
                 }
             }
         } else {
-            let tidx = labels.get(0).expect("can't extract labels");
+            let tidx = labels.first().expect("can't extract labels");
             alphas_out[*tidx as usize] += *count as f32;
         }
     }
@@ -192,7 +192,7 @@ pub fn em_optimize_subset(
     for (i, count) in cell_data {
         let labels = eqclasses.refs_for_eqc(*i);
         if labels.len() == 1 {
-            let idx = labels.get(0).expect("can't extract labels");
+            let idx = labels.first().expect("can't extract labels");
             alphas_in[*idx as usize] += *count as f32;
             unique_evidence[*idx as usize] = true;
         } else {
@@ -319,7 +319,7 @@ pub fn em_update(
                 }
             }
         } else {
-            let tidx = labels.get(0).expect("can't extract labels");
+            let tidx = labels.first().expect("can't extract labels");
             alphas_out[*tidx as usize] += *count as f32;
         }
     }
@@ -339,7 +339,7 @@ pub fn em_optimize(
 
     for (labels, count) in eqclasses {
         if labels.len() == 1 {
-            let idx = labels.get(0).expect("can't extract labels");
+            let idx = labels.first().expect("can't extract labels");
             alphas_in[*idx as usize] += *count as f32;
             unique_evidence[*idx as usize] = true;
         } else {

src/main.rs

@@ -116,7 +116,7 @@ fn main() -> anyhow::Result<()> {
             .value_parser(pathbuf_file_exists_validator)
         )
         .group(ArgGroup::new("filter-method")
-               .args(&["knee-distance", "expect-cells", "force-cells", "valid-bc", "unfiltered-pl"])
+               .args(["knee-distance", "expect-cells", "force-cells", "valid-bc", "unfiltered-pl"])
                .required(true)
                )
         .arg(
@@ -134,7 +134,7 @@ fn main() -> anyhow::Result<()> {
     .arg(arg!(-r --"rad-dir" <RADFILE> "the directory containing the RAD file to be collated")
         .required(true)
         .value_parser(pathbuf_directory_exists_validator))
-    .arg(arg!(-t --threads <THREADS> "number of threads to use for processing").value_parser(value_parser!(u32)).default_value(max_num_collate_threads.clone()))
+    .arg(arg!(-t --threads <THREADS> "number of threads to use for processing").value_parser(value_parser!(u32)).default_value(max_num_collate_threads))
     .arg(arg!(-c --compress "compress the output collated RAD file"))
     .arg(arg!(-m --"max-records" <MAXRECORDS> "the maximum number of read records to keep in memory at once")
          .value_parser(value_parser!(u32))
@@ -204,7 +204,7 @@ fn main() -> anyhow::Result<()> {
         .required(true)
         .value_parser(pathbuf_file_exists_validator))
     .arg(arg!(-o --"output-dir" <OUTPUTDIR> "output directory where quantification results will be written").required(true).value_parser(value_parser!(PathBuf)))
-    .arg(arg!(-t --threads <THREADS> "number of threads to use for processing").value_parser(value_parser!(u32)).default_value(max_num_threads.clone()))
+    .arg(arg!(-t --threads <THREADS> "number of threads to use for processing").value_parser(value_parser!(u32)).default_value(max_num_threads))
     .arg(arg!(--usa "flag specifying that input equivalence classes were computed in USA mode"))
     .arg(arg!(--"quant-subset" <SFILE> "file containing list of barcodes to quantify, those not in this list will be ignored").value_parser(pathbuf_file_exists_validator))
     .arg(arg!(--"use-mtx" "flag for writing output matrix in matrix market format (default)"))

src/quant.rs

@@ -47,7 +47,7 @@ use libradicl::rad_types;
 
 type BufferedGzFile = BufWriter<GzEncoder<fs::File>>;
 
-#[derive(PartialEq, Debug, Clone, Copy, Serialize)]
+#[derive(PartialEq, Eq, Debug, Clone, Copy, Serialize)]
 pub enum SplicedAmbiguityModel {
     PreferAmbiguity,
     WinnerTakeAll,
@@ -71,7 +71,7 @@ impl FromStr for SplicedAmbiguityModel {
     }
 }
 
-#[derive(PartialEq, Debug, Clone, Copy, Serialize)]
+#[derive(PartialEq, Eq, Debug, Clone, Copy, Serialize)]
 pub enum ResolutionStrategy {
     Trivial,
     CellRangerLike,

src/utils.rs

@@ -80,7 +80,7 @@ pub fn write_permit_list_freq(
     bclen: u16,
     permit_freq_map: &HashMap<u64, u64, ahash::RandomState>,
 ) -> Result<(), Box<dyn std::error::Error>> {
-    let output = std::fs::File::create(&o_path)?;
+    let output = std::fs::File::create(o_path)?;
     let mut writer = BufWriter::new(&output);
 
     {
@@ -731,7 +731,7 @@ pub fn is_velo_mode(input_dir: &PathBuf) -> bool {
 }
 
 #[allow(dead_code)]
-#[derive(Debug, PartialEq)]
+#[derive(Debug, PartialEq, Eq)]
 pub struct InternalVersionInfo {
     pub major: u32,
     pub minor: u32,