From 0540ebb49e048fa44d14be6e210f1c2736be1c8e Mon Sep 17 00:00:00 2001 From: Paul Masurel Date: Mon, 19 Feb 2018 12:36:24 +0900 Subject: [PATCH] Cargo clippy --- src/common/bitset.rs | 4 ++-- src/core/searcher.rs | 4 ++-- src/lib.rs | 1 + src/postings/mod.rs | 1 + src/query/bitset/mod.rs | 10 ++++----- src/query/boolean_query/boolean_weight.rs | 26 ++++++++--------------- src/query/phrase_query/phrase_scorer.rs | 18 ++++++++-------- src/query/range_query.rs | 16 +++++++------- src/query/reqopt_scorer.rs | 6 +----- src/store/reader.rs | 2 +- src/store/writer.rs | 6 +++--- src/termdict/fstdict/term_info_store.rs | 13 ++++++------ src/termdict/fstdict/termdict.rs | 2 +- 13 files changed, 49 insertions(+), 60 deletions(-) diff --git a/src/common/bitset.rs b/src/common/bitset.rs index 5284d6500..c0edea292 100644 --- a/src/common/bitset.rs +++ b/src/common/bitset.rs @@ -51,7 +51,7 @@ impl TinySet { /// within `[0; 64[` #[inline(always)] pub fn singleton(el: u32) -> TinySet { - TinySet(1u64 << (el as u64)) + TinySet(1u64 << u64::from(el)) } /// Insert a new element within [0..64[ @@ -109,7 +109,7 @@ impl TinySet { /// /// The limit is assumed to be strictly lower than 64. pub fn range_lower(upper_bound: u32) -> TinySet { - TinySet((1u64 << ((upper_bound % 64u32) as u64)) - 1u64) + TinySet((1u64 << u64::from(upper_bound % 64u32)) - 1u64) } /// Returns a `TinySet` that contains all values greater diff --git a/src/core/searcher.rs b/src/core/searcher.rs index 57e76bcc3..ca042e5e6 100644 --- a/src/core/searcher.rs +++ b/src/core/searcher.rs @@ -37,7 +37,7 @@ impl Searcher { self.segment_readers .iter() .map(|segment_reader| segment_reader.num_docs()) - .fold(0u32, |acc, val| acc + val) + .sum::() } /// Return the overall number of documents containing @@ -46,7 +46,7 @@ impl Searcher { self.segment_readers .iter() .map(|segment_reader| segment_reader.inverted_index(term.field()).doc_freq(term)) - .fold(0u32, |acc, val| acc + val) + .sum::() } /// Return the list of segment readers diff --git a/src/lib.rs b/src/lib.rs index 9bb2f20b1..bd8c31e80 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -12,6 +12,7 @@ #![doc(test(attr(allow(unused_variables), deny(warnings))))] #![allow(unknown_lints)] #![allow(new_without_default)] +#![allow(decimal_literal_representation)] #![warn(missing_docs)] //! # `tantivy` diff --git a/src/postings/mod.rs b/src/postings/mod.rs index fab52cf52..112519b99 100644 --- a/src/postings/mod.rs +++ b/src/postings/mod.rs @@ -27,6 +27,7 @@ pub use common::HasLen; pub(crate) type UnorderedTermId = usize; +#[allow(enum_variant_names)] pub(crate) enum FreqReadingOption { NoFreq, SkipFreq, diff --git a/src/query/bitset/mod.rs b/src/query/bitset/mod.rs index 7b20c2a71..1d2e78c20 100644 --- a/src/query/bitset/mod.rs +++ b/src/query/bitset/mod.rs @@ -74,13 +74,11 @@ impl DocSet for BitSetDocSet { self.cursor_tinybitset = self.cursor_tinybitset.intersect(greater_filter); if !self.advance() { SkipResult::End + } else if self.doc() == target { + SkipResult::Reached } else { - if self.doc() == target { - SkipResult::Reached - } else { - debug_assert!(self.doc() > target); - SkipResult::OverStep - } + debug_assert!(self.doc() > target); + SkipResult::OverStep } } Ordering::Equal => loop { diff --git a/src/query/boolean_query/boolean_weight.rs b/src/query/boolean_query/boolean_weight.rs index 182f8c05f..a67f68e52 100644 --- a/src/query/boolean_query/boolean_weight.rs +++ b/src/query/boolean_query/boolean_weight.rs @@ -21,18 +21,14 @@ where if scorers.len() == 1 { scorers.into_iter().next().unwrap() //< we checked the size beforehands } else { - if scorers.iter().all(|scorer| { + let is_all_term_queries = scorers.iter().all(|scorer| { let scorer_ref: &Scorer = scorer.borrow(); Downcast::::is_type(scorer_ref) - }) { + }); + if is_all_term_queries { let scorers: Vec = scorers .into_iter() - .map(|scorer| { - *Downcast::::downcast(scorer).expect( - "downcasting should not have failed, we\ - checked in advance that the type were correct.", - ) - }) + .map(|scorer| *Downcast::::downcast(scorer).unwrap()) .collect(); let scorer: Box = box Union::::from(scorers); scorer @@ -61,7 +57,7 @@ impl BooleanWeight { reader: &SegmentReader, ) -> Result> { let mut per_occur_scorers: HashMap>> = HashMap::new(); - for &(ref occur, ref subweight) in self.weights.iter() { + for &(ref occur, ref subweight) in &self.weights { let sub_scorer: Box = subweight.scorer(reader)?; per_occur_scorers .entry(*occur) @@ -82,18 +78,14 @@ impl BooleanWeight { if scorers.len() == 1 { scorers.into_iter().next().unwrap() } else { - if scorers.iter().all(|scorer| { + let is_all_term_queries = scorers.iter().all(|scorer| { let scorer_ref: &Scorer = scorer.borrow(); Downcast::::is_type(scorer_ref) - }) { + }); + if is_all_term_queries { let scorers: Vec = scorers .into_iter() - .map(|scorer| { - *Downcast::::downcast(scorer).expect( - "downcasting should not have failed, we\ - checked in advance that the type were correct.", - ) - }) + .map(|scorer| *Downcast::::downcast(scorer).unwrap()) .collect(); let scorer: Box = box Intersection::from(scorers); scorer diff --git a/src/query/phrase_query/phrase_scorer.rs b/src/query/phrase_query/phrase_scorer.rs index fe37f5258..47ae7d64e 100644 --- a/src/query/phrase_query/phrase_scorer.rs +++ b/src/query/phrase_query/phrase_scorer.rs @@ -121,19 +121,19 @@ impl DocSet for PhraseScorer { fn skip_next(&mut self, target: DocId) -> SkipResult { if self.intersection_docset.skip_next(target) == SkipResult::End { - SkipResult::End - } else if self.phrase_match() { + return SkipResult::End; + } + if self.phrase_match() { if self.doc() == target { - SkipResult::Reached + return SkipResult::Reached; } else { - SkipResult::OverStep + return SkipResult::OverStep; } + } + if self.advance() { + SkipResult::OverStep } else { - if self.advance() { - SkipResult::OverStep - } else { - SkipResult::End - } + SkipResult::End } } diff --git a/src/query/range_query.rs b/src/query/range_query.rs index 43b611352..7460223fc 100644 --- a/src/query/range_query.rs +++ b/src/query/range_query.rs @@ -150,15 +150,15 @@ impl RangeWeight { { use std::collections::Bound::*; let mut term_stream_builder = term_dict.range(); - term_stream_builder = match &self.left_bound { - &Included(ref term_val) => term_stream_builder.ge(term_val), - &Excluded(ref term_val) => term_stream_builder.gt(term_val), - &Unbounded => term_stream_builder, + term_stream_builder = match self.left_bound { + Included(ref term_val) => term_stream_builder.ge(term_val), + Excluded(ref term_val) => term_stream_builder.gt(term_val), + Unbounded => term_stream_builder, }; - term_stream_builder = match &self.right_bound { - &Included(ref term_val) => term_stream_builder.le(term_val), - &Excluded(ref term_val) => term_stream_builder.lt(term_val), - &Unbounded => term_stream_builder, + term_stream_builder = match self.right_bound { + Included(ref term_val) => term_stream_builder.le(term_val), + Excluded(ref term_val) => term_stream_builder.lt(term_val), + Unbounded => term_stream_builder, }; term_stream_builder.into_stream() } diff --git a/src/query/reqopt_scorer.rs b/src/query/reqopt_scorer.rs index 14e8dfea1..e9f98d4a7 100644 --- a/src/query/reqopt_scorer.rs +++ b/src/query/reqopt_scorer.rs @@ -50,11 +50,7 @@ where { fn advance(&mut self) -> bool { self.score_cache = None; - if self.req_scorer.advance() { - true - } else { - false - } + self.req_scorer.advance() } fn doc(&self) -> DocId { diff --git a/src/store/reader.rs b/src/store/reader.rs index f1d139d6d..0940bd752 100644 --- a/src/store/reader.rs +++ b/src/store/reader.rs @@ -40,7 +40,7 @@ impl StoreReader { fn block_offset(&self, doc_id: DocId) -> (DocId, u64) { self.block_index() - .seek(doc_id as u64 + 1) + .seek(u64::from(doc_id) + 1) .map(|(doc, offset)| (doc as DocId, offset)) .unwrap_or((0u32, 0u64)) } diff --git a/src/store/writer.rs b/src/store/writer.rs index ad356e870..50f6ade8a 100644 --- a/src/store/writer.rs +++ b/src/store/writer.rs @@ -67,7 +67,7 @@ impl StoreWriter { if !self.current_block.is_empty() { self.write_and_compress_block()?; self.offset_index_writer - .insert(self.doc as u64, &(self.writer.written_bytes() as u64))?; + .insert(u64::from(self.doc), &(self.writer.written_bytes() as u64))?; } let doc_offset = self.doc; let start_offset = self.writer.written_bytes() as u64; @@ -80,7 +80,7 @@ impl StoreWriter { for (next_doc_id, block_addr) in store_reader.block_index() { self.doc = doc_offset + next_doc_id as u32; self.offset_index_writer - .insert(self.doc as u64, &(start_offset + block_addr))?; + .insert(u64::from(self.doc), &(start_offset + block_addr))?; } Ok(()) } @@ -96,7 +96,7 @@ impl StoreWriter { (self.intermediary_buffer.len() as u32).serialize(&mut self.writer)?; self.writer.write_all(&self.intermediary_buffer)?; self.offset_index_writer - .insert(self.doc as u64, &(self.writer.written_bytes() as u64))?; + .insert(u64::from(self.doc), &(self.writer.written_bytes() as u64))?; self.current_block.clear(); Ok(()) } diff --git a/src/termdict/fstdict/term_info_store.rs b/src/termdict/fstdict/term_info_store.rs index 63d8d4957..1f7ca9779 100644 --- a/src/termdict/fstdict/term_info_store.rs +++ b/src/termdict/fstdict/term_info_store.rs @@ -1,3 +1,4 @@ + use std::io; use std::cmp; use std::io::{Read, Write}; @@ -94,12 +95,12 @@ fn extract_bits(data: &[u8], addr_bits: usize, num_bits: u8) -> u64 { let bit_shift = (addr_bits % 8) as u64; let val_unshifted_unmasked: u64 = unsafe { *(data[addr_byte..].as_ptr() as *const u64) }; let val_shifted_unmasked = val_unshifted_unmasked >> bit_shift; - let mask = (1u64 << (num_bits as u64)) - 1; + let mask = (1u64 << u64::from(num_bits)) - 1; val_shifted_unmasked & mask } impl TermInfoStore { - pub fn open(data: ReadOnlySource) -> TermInfoStore { + pub fn open(data: &ReadOnlySource) -> TermInfoStore { let buffer = data.as_slice(); let len = Endianness::read_u64(&buffer[0..8]) as usize; let num_terms = Endianness::read_u64(&buffer[8..16]) as usize; @@ -149,7 +150,7 @@ fn bitpack_serialize( term_info: &TermInfo, ) -> io::Result<()> { bit_packer.write( - term_info.doc_freq as u64, + u64::from(term_info.doc_freq), term_info_block_meta.doc_freq_nbits, write, )?; @@ -163,7 +164,7 @@ fn bitpack_serialize( term_info_block_meta.positions_offset_nbits, write, )?; - bit_packer.write(term_info.positions_inner_offset as u64, 7, write)?; + bit_packer.write(u64::from(term_info.positions_inner_offset), 7, write)?; Ok(()) } @@ -197,7 +198,7 @@ impl TermInfoStoreWriter { max_positions_offset = cmp::max(max_positions_offset, term_info.positions_offset); } - let max_doc_freq_nbits: u8 = compute_num_bits(max_doc_freq as u64); + let max_doc_freq_nbits: u8 = compute_num_bits(u64::from(max_doc_freq)); let max_postings_offset_nbits = compute_num_bits(max_postings_offset); let max_positions_offset_nbits = compute_num_bits(max_positions_offset); @@ -321,7 +322,7 @@ mod tests { } let mut buffer = Vec::new(); store_writer.serialize(&mut buffer).unwrap(); - let term_info_store = TermInfoStore::open(ReadOnlySource::from(buffer)); + let term_info_store = TermInfoStore::open(&ReadOnlySource::from(buffer)); for i in 0..1000 { assert_eq!(term_info_store.get(i as u64), term_infos[i]); } diff --git a/src/termdict/fstdict/termdict.rs b/src/termdict/fstdict/termdict.rs index 4a4d1be9a..4583518c7 100644 --- a/src/termdict/fstdict/termdict.rs +++ b/src/termdict/fstdict/termdict.rs @@ -116,7 +116,7 @@ impl<'a> TermDictionary<'a> for TermDictionaryImpl { let fst_index = open_fst_index(fst_source); TermDictionaryImpl { fst_index, - term_info_store: TermInfoStore::open(values_source), + term_info_store: TermInfoStore::open(&values_source), } }