Bump to Rust 2018 and fix clippy (& other) lints

Author: Roderick Bovee

Cargo.toml

@@ -1,7 +1,8 @@
 [package]
 name = "bfield"
-version = "0.1.2"
+version = "0.1.3"
 authors = ["Roderick Bovee <roderick@onecodex.com>"]
+edition = "2018"
 
 [dependencies]
 bincode = "0.9.2"

src/bfield.rs

@@ -4,8 +4,8 @@ use std::path::Path;
 use serde::Serialize;
 use serde::de::DeserializeOwned;
 
-use bfield_member::{BFieldLookup, BFieldMember, BFieldVal};
-use marker::{to_marker};
+use crate::bfield_member::{BFieldLookup, BFieldMember, BFieldVal};
+use crate::marker::{to_marker};
 
 
 pub struct BField<T> {
@@ -57,7 +57,7 @@ impl<'a, T: Clone + DeserializeOwned + Serialize> BField<T> {
         let _ = to_marker(0, n_marker_bits);
 
         Ok(BField {
-            members: members,
+            members,
             read_only: false,
         })
     }
@@ -81,15 +81,15 @@ impl<'a, T: Clone + DeserializeOwned + Serialize> BField<T> {
             members.push(member);
             n += 1;
         }
-        if members.len() == 0 {
+        if members.is_empty() {
             return Err(io::Error::new(
                 io::ErrorKind::NotFound,
                 format!("No Bfield found at {:?}", filename.as_ref())
             ));
         }
         Ok(BField {
-            members: members,
-            read_only: read_only,
+            members,
+            read_only,
         })
     }
 
@@ -114,7 +114,7 @@ impl<'a, T: Clone + DeserializeOwned + Serialize> BField<T> {
             n += 1;
         }
         Ok(BField {
-            members: members,
+            members,
             read_only: true,
         })
     }

src/bfield_member.rs

@@ -4,19 +4,17 @@ use std::fs::File;
 #[cfg(feature = "prefetching")]
 use std::intrinsics;
 use std::io;
-use std::ops::Range;
 use std::path::Path;
 
 use bincode::{serialize, deserialize, Infinite};
 use mmap_bitvec::{BitVector, MmapBitVec, BitVecSlice};
-use mmap_bitvec::bitvec::BIT_VEC_SLICE_SIZE;
 use murmurhash3::murmurhash3_x64_128;
 use serde::Serialize;
 use serde::de::DeserializeOwned;
 #[cfg(feature = "legacy")]
 use serde_json;
 
-use marker::{from_marker, to_marker};
+use crate::marker::{from_marker, to_marker};
 
 
 #[derive(Debug, Deserialize, Serialize)]
@@ -55,9 +53,9 @@ impl<T: Clone + DeserializeOwned + Serialize> BFieldMember<T> {
         P: AsRef<Path>,
     {
         let bf_params = BFieldParams {
-            n_hashes: n_hashes,
-            marker_width: marker_width,
-            n_marker_bits: n_marker_bits,
+            n_hashes,
+            marker_width,
+            n_marker_bits,
             other: other_params,
         };
 
@@ -121,9 +119,9 @@ impl<T: Clone + DeserializeOwned + Serialize> BFieldMember<T> {
         n_marker_bits: u8,
     ) -> Result<Self, io::Error> {
         let bf_params = BFieldParams {
-            n_hashes: n_hashes,
-            marker_width: marker_width,
-            n_marker_bits: n_marker_bits,
+            n_hashes,
+            marker_width,
+            n_marker_bits,
             other: None,
         };
 
@@ -230,9 +228,8 @@ impl<T: Clone + DeserializeOwned + Serialize> BFieldMember<T> {
         }
 
         assert!(self.params.n_hashes <= 16);
-        for marker_ix in 0usize..self.params.n_hashes as usize {
-            let pos = positions[marker_ix];
-            let marker =  self.bitvec.get_range(pos..pos + marker_width);
+        for pos in positions.iter().take(self.params.n_hashes as usize) {
+            let marker =  self.bitvec.get_range(*pos..*pos + marker_width);
             merged_marker &= marker;
             if merged_marker.count_ones() < k {
                 return 0;
@@ -305,16 +302,16 @@ fn test_bfield() {
 
 #[test]
 fn test_bfield_collisions() {
-    // comically small bfield with too many hashes to cause saturation
-    let mut bfield: BFieldMember<usize> = BFieldMember::in_memory(128, 100, 16, 4).unwrap();
+    // comically small bfield with too many (16) hashes
+    // and too many bits (8) to cause saturation
+    let mut bfield: BFieldMember<usize> = BFieldMember::in_memory(128, 16, 64, 8).unwrap();
 
     bfield.insert(b"test", 100);
     assert_eq!(bfield.get(b"test"), BFieldLookup::Indeterminate);
 }
 
 #[test]
 fn test_bfield_bits_set() {
-    // comically small bfield with too many hashes to cause saturation
     let mut bfield: BFieldMember<usize> = BFieldMember::in_memory(128, 2, 16, 4).unwrap();
 
     bfield.insert(b"test", 100);

src/lib.rs

@@ -1,17 +1,12 @@
 #![cfg_attr(feature = "marker_lookup", feature(const_fn))]
 #![cfg_attr(feature = "prefetching", feature(core_intrinsics))]
-extern crate bincode;
-extern crate mmap_bitvec;
-extern crate murmurhash3;
-extern crate serde;
+
 #[macro_use]
 extern crate serde_derive;
-#[cfg(feature = "legacy")]
-extern crate serde_json;
 
 mod bfield;
 mod bfield_member;
 mod marker;
 
-pub use bfield::BField;
-pub use bfield_member::BFieldVal;
+pub use crate::bfield::BField;
+pub use crate::bfield_member::BFieldVal;

src/marker.rs

@@ -1,7 +1,8 @@
 #![cfg_attr(feature = "const_fn", feature(marker_lookup))]
 
 use mmap_bitvec::BitVecSlice;
-use bfield_member::BFieldVal;
+
+use crate::bfield_member::BFieldVal;
 
 #[cfg(feature = "marker_lookup")]
 const MARKER_TABLE_SIZE: usize = 200000;
@@ -12,14 +13,22 @@ static mut MARKER_BITS: u8 = 0;
 
 #[cfg(feature = "marker_lookup")]
 pub fn to_marker(value: BFieldVal, k: u8) -> BitVecSlice {
+    // note that you can only test this feature with
+    // `RUST_TEST_THREADS=1 cargo test` or else you'll get tons of
+    // errors because of data races between threads with different k's
+
+    // also some tests (i.e. ones with k=1) fail because there are fewer
+    // than 200000 possible values for the table
     unsafe {
+        // clear out the lookup table if we have a new k and fill
+        // it with values for the new k
         if MARKER_BITS != k {
-            MARKER_BITS = k;
             MARKER_TABLE = [0; MARKER_TABLE_SIZE];
             MARKER_TABLE[0] = (1 << k) - 1 as BitVecSlice;
             for i in 1..MARKER_TABLE_SIZE {
                 MARKER_TABLE[i] = next_marker(MARKER_TABLE[i - 1]);
             }
+            MARKER_BITS = k;
         }
         if value as usize >= MARKER_TABLE_SIZE {
             let mut marker = MARKER_TABLE[MARKER_TABLE_SIZE - 1];
@@ -64,7 +73,7 @@ pub fn from_marker(marker: BitVecSlice) -> BFieldVal {
     let mut value = 0u64;
     let mut idx = 0;
     while working_marker != 0 {
-        let rank = working_marker.trailing_zeros() as u64;
+        let rank = u64::from(working_marker.trailing_zeros());
         working_marker -= 1 << rank;
         idx += 1;
         value += choose(rank, idx);