Appease Clippy

Author: sampsyo

flatgfa-py/src/lib.rs

@@ -169,7 +169,7 @@ impl ListRef {
     {
         match arg {
             SliceOrInt::Slice(slice) => {
-                let indices = slice.indices(self.len().try_into().unwrap())?;
+                let indices = slice.indices(self.len().into())?;
                 if indices.step == 1 {
                     Ok(L::from(self.slice(indices.start as u32, indices.stop as u32)).into_py(py))
                 } else {
@@ -547,7 +547,7 @@ impl StepList {
     fn __getitem__(&self, arg: SliceOrInt, py: Python) -> PyResult<PyObject> {
         match arg {
             SliceOrInt::Slice(slice) => {
-                let indices = slice.indices(self.0.len().try_into().unwrap())?;
+                let indices = slice.indices(self.0.len().into())?;
                 if indices.step == 1 {
                     let list = self.0.slice(indices.start as u32, indices.stop as u32);
                     Ok(Self(list).into_py(py))

flatgfa/src/cli/cmds.rs

@@ -271,32 +271,30 @@ pub fn gaf_lookup(gfa: &flatgfa::FlatGFA, args: GAFLookup) {
         } else {
             unimplemented!("only the no-op mode is parallel")
         }
-    } else {
-        if args.seqs {
-            // Print the actual sequences for each chunk in the GAF.
-            for read in parser {
-                print!("{}\t", read.name);
-                for event in ops::gaf::PathChunker::new(gfa, &name_map, read) {
-                    event.print_seq(gfa);
-                }
-                println!();
+    } else if args.seqs {
+        // Print the actual sequences for each chunk in the GAF.
+        for read in parser {
+            print!("{}\t", read.name);
+            for event in ops::gaf::PathChunker::new(gfa, &name_map, read) {
+                event.print_seq(gfa);
             }
-        } else if args.bench {
-            // Benchmarking mode: just process all the chunks but print nothing.
-            let mut count = 0;
-            for read in parser {
-                for _event in ops::gaf::PathChunker::new(gfa, &name_map, read) {
-                    count += 1;
-                }
+            println!();
+        }
+    } else if args.bench {
+        // Benchmarking mode: just process all the chunks but print nothing.
+        let mut count = 0;
+        for read in parser {
+            for _event in ops::gaf::PathChunker::new(gfa, &name_map, read) {
+                count += 1;
             }
-            println!("{}", count);
-        } else {
-            // Just print some info about the offsets in the segments.
-            for read in parser {
-                println!("{}", read.name);
-                for event in ops::gaf::PathChunker::new(gfa, &name_map, read) {
-                    event.print(gfa);
-                }
+        }
+        println!("{}", count);
+    } else {
+        // Just print some info about the offsets in the segments.
+        for read in parser {
+            println!("{}", read.name);
+            for event in ops::gaf::PathChunker::new(gfa, &name_map, read) {
+                event.print(gfa);
             }
         }
     }

flatgfa/src/file.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::repr_packed_without_abi)]
+
 use crate::flatgfa;
 use crate::pool::{FixedStore, Pool, Span, Store};
 use std::mem::{size_of, size_of_val};

flatgfa/src/flatgfa.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::repr_packed_without_abi)]
+
 use std::ops::Range;
 use std::str::FromStr;
 
@@ -174,7 +176,7 @@ impl Handle {
         assert!(seg_num & (1 << (u32::BITS - 1)) == 0, "index too large");
         let orient_bit: u8 = orient.into();
         assert!(orient_bit & !1 == 0, "invalid orientation");
-        Self(seg_num << 1 | (orient_bit as u32))
+        Self((seg_num << 1) | (orient_bit as u32))
     }
 
     /// Get the segment ID. This is an index in the `segs` pool.
@@ -311,7 +313,7 @@ fn nucleotide_complement(c: u8) -> u8 {
     }
 }
 
-impl<'a> std::fmt::Display for Sequence<'a> {
+impl std::fmt::Display for Sequence<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         if self.revcmp {
             // For small sequences, it's faster to allocate the reverse-complement

flatgfa/src/gfaline.rs

@@ -227,7 +227,7 @@ impl<'a> StepsParser<'a> {
     }
 }
 
-impl<'a> Iterator for StepsParser<'a> {
+impl Iterator for StepsParser<'_> {
     type Item = (usize, bool);
     fn next(&mut self) -> Option<(usize, bool)> {
         while self.index < self.str.len() {

flatgfa/src/memfile.rs

@@ -13,6 +13,7 @@ pub fn map_new_file(name: &str, size: u64) -> MmapMut {
     let file = std::fs::OpenOptions::new()
         .read(true)
         .write(true)
+        .truncate(true)
         .create(true)
         .open(name)
         .unwrap();

flatgfa/src/ops/bench.rs

@@ -3,7 +3,7 @@ use rayon::iter::ParallelIterator;
 
 // Count the lines in a file, like `wc -l`.
 pub fn line_count(filename: &str, parallel: bool) -> usize {
-    let buf = memfile::map_file(&filename);
+    let buf = memfile::map_file(filename);
     let split = memfile::MemchrSplit::new(b'\n', &buf);
     if parallel {
         ParallelIterator::count(split)

flatgfa/src/ops/gaf.rs

@@ -42,7 +42,7 @@ impl<'a> GAFLineParser<'a> {
 
     fn int_field(&mut self) -> Option<usize> {
         let mut pos = 0;
-        let val = parse_int(&self.buf, &mut pos);
+        let val = parse_int(self.buf, &mut pos);
         assert!(matches!(self.buf[pos], b'\t' | b'\n'));
         self.advance(pos + 1);
         val
@@ -193,7 +193,7 @@ impl ChunkEvent {
     }
 }
 
-impl<'a, 'b> Iterator for PathChunker<'a, 'b> {
+impl Iterator for PathChunker<'_, '_> {
     type Item = ChunkEvent;
 
     fn next(&mut self) -> Option<ChunkEvent> {
@@ -278,13 +278,13 @@ fn parse_int(bytes: &[u8], index: &mut usize) -> Option<usize> {
     }
 
     if first_digit {
-        return None;
+        None
     } else {
-        return Some(num);
+        Some(num)
     }
 }
 
-impl<'a> Iterator for PathParser<'a> {
+impl Iterator for PathParser<'_> {
     type Item = (usize, bool);
 
     fn next(&mut self) -> Option<(usize, bool)> {
@@ -303,7 +303,7 @@ impl<'a> Iterator for PathParser<'a> {
 
         // Parse the integer segment name.
         let seg_name = parse_int(self.str, &mut self.index)?;
-        return Some((seg_name, forward));
+        Some((seg_name, forward))
     }
 }
 

flatgfa/src/parse.rs

@@ -148,7 +148,7 @@ impl<'a, P: flatgfa::StoreFamily<'a>> Parser<'a, P> {
 
     fn add_path(&mut self, path: gfaline::Path) {
         // Parse the steps.
-        let mut step_parser = gfaline::StepsParser::new(&path.steps);
+        let mut step_parser = gfaline::StepsParser::new(path.steps);
         let steps = self.flat.add_steps((&mut step_parser).map(|(name, dir)| {
             Handle::new(
                 self.seg_ids.get(name),

flatgfa/src/pool.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::repr_packed_without_abi)]
+
 use std::ops::{Add, Index, Sub};
 use std::{hash::Hash, marker::PhantomData};
 use tinyvec::SliceVec;
@@ -195,7 +197,7 @@ impl<T> Default for HeapStore<T> {
 #[repr(transparent)]
 pub struct FixedStore<'a, T>(SliceVec<'a, T>);
 
-impl<'a, T: Clone> Store<T> for FixedStore<'a, T> {
+impl<T: Clone> Store<T> for FixedStore<'_, T> {
     fn as_ref(&self) -> Pool<T> {
         Pool(&self.0)
     }
@@ -223,7 +225,7 @@ impl<'a, T: Clone> Store<T> for FixedStore<'a, T> {
     }
 }
 
-impl<'a, T> FixedStore<'a, T> {
+impl<T> FixedStore<'_, T> {
     pub fn capacity(&self) -> usize {
         self.0.capacity()
     }