Clippy comment + removing fill_vals

Author: fulmicoton-dd

columnar/src/column/mod.rs

@@ -131,6 +131,8 @@ impl<T: PartialOrd + Copy + Debug + Send + Sync + 'static> Column<T> {
         self.index.docids_to_rowids(doc_ids, doc_ids_out, row_ids)
     }
 
+    /// Get an iterator over the values for the provided docid.
+    #[inline]
     pub fn values_for_doc(&self, doc_id: DocId) -> impl Iterator<Item = T> + '_ {
         self.index
             .value_row_ids(doc_id)
@@ -158,15 +160,6 @@ impl<T: PartialOrd + Copy + Debug + Send + Sync + 'static> Column<T> {
             .select_batch_in_place(selected_docid_range.start, doc_ids);
     }
 
-    /// Fills the output vector with the (possibly multiple values that are associated_with
-    /// `row_id`.
-    ///
-    /// This method clears the `output` vector.
-    pub fn fill_vals(&self, row_id: RowId, output: &mut Vec<T>) {
-        output.clear();
-        output.extend(self.values_for_doc(row_id));
-    }
-
     pub fn first_or_default_col(self, default_value: T) -> Arc<dyn ColumnValues<T>> {
         Arc::new(FirstValueWithDefault {
             column: self,

src/fastfield/mod.rs

@@ -726,22 +726,22 @@ mod tests {
             .column_opt::<DateTime>("multi_date")
             .unwrap()
             .unwrap();
-        let mut dates = Vec::new();
+
         {
             assert_eq!(date_fast_field.get_val(0).into_timestamp_nanos(), 1i64);
-            dates_fast_field.fill_vals(0u32, &mut dates);
+            let dates: Vec<DateTime> = dates_fast_field.values_for_doc(0u32).collect();
             assert_eq!(dates.len(), 2);
             assert_eq!(dates[0].into_timestamp_nanos(), 2i64);
             assert_eq!(dates[1].into_timestamp_nanos(), 3i64);
         }
         {
             assert_eq!(date_fast_field.get_val(1).into_timestamp_nanos(), 4i64);
-            dates_fast_field.fill_vals(1u32, &mut dates);
+            let dates: Vec<DateTime> = dates_fast_field.values_for_doc(1u32).collect();
             assert!(dates.is_empty());
         }
         {
             assert_eq!(date_fast_field.get_val(2).into_timestamp_nanos(), 0i64);
-            dates_fast_field.fill_vals(2u32, &mut dates);
+            let dates: Vec<DateTime> = dates_fast_field.values_for_doc(2u32).collect();
             assert_eq!(dates.len(), 2);
             assert_eq!(dates[0].into_timestamp_nanos(), 5i64);
             assert_eq!(dates[1].into_timestamp_nanos(), 6i64);

src/query/range_query/range_query.rs

@@ -269,7 +269,7 @@ mod tests {
     use crate::query::range_query::fast_field_range_doc_set::RangeDocSet;
     use crate::query::range_query::range_query::InvertedIndexRangeQuery;
     use crate::query::{
-        AllScorer, BitSetDocSet, ConstScorer, EmptyScorer, EnableScoring, Query, QueryParser,
+        AllScorer, ConstScorer, EmptyScorer, EnableScoring, Query, QueryParser,
     };
     use crate::schema::{
         Field, IntoIpv6Addr, Schema, TantivyDocument, FAST, INDEXED, STORED, TEXT,

src/query/term_query/term_weight.rs

@@ -18,15 +18,15 @@ pub struct TermWeight {
 }
 
 enum TermOrEmptyOrAllScorer {
-    TermScorer(TermScorer),
+    TermScorer(Box<TermScorer>),
     Empty,
     AllMatch(AllScorer),
 }
 
 impl TermOrEmptyOrAllScorer {
     pub fn into_boxed_scorer(self) -> Box<dyn Scorer> {
         match self {
-            TermOrEmptyOrAllScorer::TermScorer(scorer) => Box::new(scorer),
+            TermOrEmptyOrAllScorer::TermScorer(scorer) => scorer,
             TermOrEmptyOrAllScorer::Empty => Box::new(EmptyScorer),
             TermOrEmptyOrAllScorer::AllMatch(scorer) => Box::new(scorer),
         }
@@ -49,7 +49,7 @@ impl Weight for TermWeight {
                 Ok(explanation)
             }
             TermOrEmptyOrAllScorer::Empty => {
-                return Err(does_not_match(doc));
+                Err(does_not_match(doc))
             }
             TermOrEmptyOrAllScorer::AllMatch(_) => AllWeight.explain(reader, doc),
         }
@@ -75,7 +75,7 @@ impl Weight for TermWeight {
     ) -> crate::Result<()> {
         match self.specialized_scorer(reader, 1.0)? {
             TermOrEmptyOrAllScorer::TermScorer(mut term_scorer) => {
-                for_each_scorer(&mut term_scorer, callback);
+                for_each_scorer(&mut *term_scorer, callback);
             }
             TermOrEmptyOrAllScorer::Empty => {}
             TermOrEmptyOrAllScorer::AllMatch(mut all_scorer) => {
@@ -127,7 +127,7 @@ impl Weight for TermWeight {
         match specialized_scorer {
             TermOrEmptyOrAllScorer::TermScorer(term_scorer) => {
                 crate::query::boolean_query::block_wand_single_scorer(
-                    term_scorer,
+                    *term_scorer,
                     threshold,
                     callback,
                 );
@@ -173,7 +173,7 @@ impl TermWeight {
     ) -> crate::Result<Option<TermScorer>> {
         let scorer = self.specialized_scorer(reader, boost)?;
         Ok(match scorer {
-            TermOrEmptyOrAllScorer::TermScorer(scorer) => Some(scorer),
+            TermOrEmptyOrAllScorer::TermScorer(scorer) => Some(*scorer),
             _ => None,
         })
     }
@@ -203,11 +203,11 @@ impl TermWeight {
 
         let fieldnorm_reader = self.fieldnorm_reader(reader)?;
         let similarity_weight = self.similarity_weight.boost_by(boost);
-        Ok(TermOrEmptyOrAllScorer::TermScorer(TermScorer::new(
+        Ok(TermOrEmptyOrAllScorer::TermScorer(Box::new(TermScorer::new(
             segment_postings,
             fieldnorm_reader,
             similarity_weight,
-        )))
+        ))))
     }
 
     fn fieldnorm_reader(&self, segment_reader: &SegmentReader) -> crate::Result<FieldNormReader> {