Clippy (#421)

* Cargo Format

* Clippy

* bugfix

* still clippy stuff

* clippy step 2

4 files changed, 19 insertions, 18 deletions

diff --git a/src/termdict/merger.rs b/src/termdict/merger.rs
index ef0959c..407a49e 100644
--- a/src/termdict/merger.rs
+++ b/src/termdict/merger.rs
@@ -81,7 +81,7 @@ impl<'a> TermMerger<'a> {
     /// Advance the term iterator to the next term.
     /// Returns true if there is indeed another term
     /// False if there is none.
-    #[allow(while_let_loop)]
+    #[cfg_attr(feature = "cargo-clippy", allow(clippy::while_let_loop))]
     pub fn advance(&mut self) -> bool {
         self.advance_segments();
         if let Some(head) = self.heap.pop() {
@@ -123,7 +123,7 @@ impl<'a> TermMerger<'a> {
     }
 
     /// Iterates through terms
-    #[allow(should_implement_trait)]
+    #[cfg_attr(feature = "cargo-clippy", allow(clippy::should_implement_trait))]
     pub fn next(&mut self) -> Option<Term<&[u8]>> {
         if self.advance() {
             Some(Term::wrap(self.current_streamers[0].streamer.key()))
diff --git a/src/termdict/mod.rs b/src/termdict/mod.rs
index d403314..5ae2594 100644
--- a/src/termdict/mod.rs
+++ b/src/termdict/mod.rs
@@ -66,7 +66,7 @@ mod tests {
             let write = directory.open_write(&path).unwrap();
             let field_type = FieldType::Str(TEXT);
             let mut term_dictionary_builder =
-                TermDictionaryBuilder::new(write, field_type).unwrap();
+                TermDictionaryBuilder::new(write, &field_type).unwrap();
             for term in COUNTRIES.iter() {
                 term_dictionary_builder
                     .insert(term.as_bytes(), &make_term_info(0u64))
@@ -92,7 +92,7 @@ mod tests {
             let write = directory.open_write(&path).unwrap();
             let field_type = FieldType::Str(TEXT);
             let mut term_dictionary_builder =
-                TermDictionaryBuilder::new(write, field_type).unwrap();
+                TermDictionaryBuilder::new(write, &field_type).unwrap();
             term_dictionary_builder
                 .insert("abc".as_bytes(), &make_term_info(34u64))
                 .unwrap();
@@ -180,7 +180,7 @@ mod tests {
         let field_type = FieldType::Str(TEXT);
         let buffer: Vec<u8> = {
             let mut term_dictionary_builder =
-                TermDictionaryBuilder::new(vec![], field_type).unwrap();
+                TermDictionaryBuilder::new(vec![], &field_type).unwrap();
             for &(ref id, ref i) in &ids {
                 term_dictionary_builder
                     .insert(id.as_bytes(), &make_term_info(*i as u64))
@@ -210,7 +210,7 @@ mod tests {
         let field_type = FieldType::Str(TEXT);
         let buffer: Vec<u8> = {
             let mut term_dictionary_builder =
-                TermDictionaryBuilder::new(vec![], field_type).unwrap();
+                TermDictionaryBuilder::new(vec![], &field_type).unwrap();
             // term requires more than 16bits
             term_dictionary_builder
                 .insert("abcdefghijklmnopqrstuvwxy", &make_term_info(1))
@@ -245,7 +245,7 @@ mod tests {
         let field_type = FieldType::Str(TEXT);
         let buffer: Vec<u8> = {
             let mut term_dictionary_builder =
-                TermDictionaryBuilder::new(vec![], field_type).unwrap();
+                TermDictionaryBuilder::new(vec![], &field_type).unwrap();
             for &(ref id, ref i) in &ids {
                 term_dictionary_builder
                     .insert(id.as_bytes(), &make_term_info(*i as u64))
@@ -314,7 +314,7 @@ mod tests {
         let field_type = FieldType::Str(TEXT);
         let buffer: Vec<u8> = {
             let mut term_dictionary_builder =
-                TermDictionaryBuilder::new(vec![], field_type).unwrap();
+                TermDictionaryBuilder::new(vec![], &field_type).unwrap();
             term_dictionary_builder
                 .insert(&[], &make_term_info(1 as u64))
                 .unwrap();
@@ -338,7 +338,7 @@ mod tests {
         let field_type = FieldType::Str(TEXT);
         let buffer: Vec<u8> = {
             let mut term_dictionary_builder =
-                TermDictionaryBuilder::new(vec![], field_type).unwrap();
+                TermDictionaryBuilder::new(vec![], &field_type).unwrap();
             for i in 0u8..10u8 {
                 let number_arr = [i; 1];
                 term_dictionary_builder
@@ -408,7 +408,7 @@ mod tests {
             let write = directory.open_write(&path).unwrap();
             let field_type = FieldType::Str(TEXT);
             let mut term_dictionary_builder =
-                TermDictionaryBuilder::new(write, field_type).unwrap();
+                TermDictionaryBuilder::new(write, &field_type).unwrap();
             for term in COUNTRIES.iter() {
                 term_dictionary_builder
                     .insert(term.as_bytes(), &make_term_info(0u64))
diff --git a/src/termdict/term_info_store.rs b/src/termdict/term_info_store.rs
index 98947fe..8b6a015 100644
--- a/src/termdict/term_info_store.rs
+++ b/src/termdict/term_info_store.rs
@@ -69,7 +69,6 @@ impl TermInfoBlockMeta {
         cursor += self.postings_offset_nbits as usize;
 
         let positions_idx = extract_bits(data, cursor, self.positions_idx_nbits);
-        self.positions_idx_nbits as usize;
 
         TermInfo {
             doc_freq,
@@ -91,8 +90,10 @@ fn extract_bits(data: &[u8], addr_bits: usize, num_bits: u8) -> u64 {
     let bit_shift = (addr_bits % 8) as u64;
     assert!(data.len() >= addr_byte + 7);
     let val_unshifted_unmasked: u64 = unsafe {
-        // ok thanks to the 7 byte padding on `.close`
-        let addr = data.as_ptr().offset(addr_byte as isize) as *const u64;
+        // ok because the pointer is only accessed using `ptr::read_unaligned`
+        #[cfg_attr(feature="cargo-clippy", allow(clippy::cast_ptr_alignment))]
+        let addr = data.as_ptr().add(addr_byte) as *const u64;
+        // ok thanks to the 7 byte padding
         ptr::read_unaligned(addr)
     };
     let val_shifted_unmasked = val_unshifted_unmasked >> bit_shift;
diff --git a/src/termdict/termdict.rs b/src/termdict/termdict.rs
index 03738e6..99bea0b 100644
--- a/src/termdict/termdict.rs
+++ b/src/termdict/termdict.rs
@@ -29,7 +29,7 @@ where
     W: Write,
 {
     /// Creates a new `TermDictionaryBuilder`
-    pub fn new(w: W, _field_type: FieldType) -> io::Result<Self> {
+    pub fn new(w: W, _field_type: &FieldType) -> io::Result<Self> {
         let fst_builder = fst::MapBuilder::new(w).map_err(convert_fst_error)?;
         Ok(TermDictionaryBuilder {
             fst_builder,
@@ -129,9 +129,9 @@ impl TermDictionary {
     }
 
     /// Creates an empty term dictionary which contains no terms.
-    pub fn empty(field_type: FieldType) -> Self {
+    pub fn empty(field_type: &FieldType) -> Self {
         let term_dictionary_data: Vec<u8> =
-            TermDictionaryBuilder::new(Vec::<u8>::new(), field_type)
+            TermDictionaryBuilder::new(Vec::<u8>::new(), &field_type)
                 .expect("Creating a TermDictionaryBuilder in a Vec<u8> should never fail")
                 .finish()
                 .expect("Writing in a Vec<u8> should never fail");
@@ -193,12 +193,12 @@ impl TermDictionary {
 
     /// Returns a range builder, to stream all of the terms
     /// within an interval.
-    pub fn range<'a>(&'a self) -> TermStreamerBuilder<'a> {
+    pub fn range(&self) -> TermStreamerBuilder {
         TermStreamerBuilder::new(self, self.fst_index.range())
     }
 
     /// A stream of all the sorted terms. [See also `.stream_field()`](#method.stream_field)
-    pub fn stream<'a>(&'a self) -> TermStreamer<'a> {
+    pub fn stream(&self) -> TermStreamer {
         self.range().into_stream()
     }