Revert "return result from segment collector"

This reverts commit a99e5459e3.

examples/custom_collector.rs

@@ -102,12 +102,11 @@ struct StatsSegmentCollector {
 impl SegmentCollector for StatsSegmentCollector {
     type Fruit = Option<Stats>;
 
-    fn collect(&mut self, doc: u32, _score: Score) -> tantivy::Result<()> {
+    fn collect(&mut self, doc: u32, _score: Score) {
         let value = self.fast_field_reader.get(doc) as f64;
         self.stats.count += 1;
         self.stats.sum += value;
         self.stats.squared_sum += value * value;
-        Ok(())
     }
 
     fn harvest(self) -> <Self as SegmentCollector>::Fruit {

src/aggregation/collector.rs

@@ -158,9 +158,8 @@ impl SegmentCollector for AggregationSegmentCollector {
     type Fruit = crate::Result<IntermediateAggregationResults>;
 
     #[inline]
-    fn collect(&mut self, doc: crate::DocId, _score: crate::Score) -> crate::Result<()> {
+    fn collect(&mut self, doc: crate::DocId, _score: crate::Score) {
         self.result.collect(doc, &self.aggs_with_accessor)?;
-        Ok(())
     }
 
     fn harvest(mut self) -> Self::Fruit {

src/collector/count_collector.rs

@@ -65,9 +65,8 @@ pub struct SegmentCountCollector {
 impl SegmentCollector for SegmentCountCollector {
     type Fruit = usize;
 
-    fn collect(&mut self, _: DocId, _: Score) -> crate::Result<()> {
+    fn collect(&mut self, _: DocId, _: Score) {
         self.count += 1;
-        Ok(())
     }
 
     fn harvest(self) -> usize {
@@ -93,18 +92,18 @@ mod tests {
         }
         {
             let mut count_collector = SegmentCountCollector::default();
-            count_collector.collect(0u32, 1.0).unwrap();
+            count_collector.collect(0u32, 1.0);
             assert_eq!(count_collector.harvest(), 1);
         }
         {
             let mut count_collector = SegmentCountCollector::default();
-            count_collector.collect(0u32, 1.0).unwrap();
+            count_collector.collect(0u32, 1.0);
             assert_eq!(count_collector.harvest(), 1);
         }
         {
             let mut count_collector = SegmentCountCollector::default();
-            count_collector.collect(0u32, 1.0).unwrap();
-            count_collector.collect(1u32, 1.0).unwrap();
+            count_collector.collect(0u32, 1.0);
+            count_collector.collect(1u32, 1.0);
             assert_eq!(count_collector.harvest(), 2);
         }
     }

src/collector/custom_score_top_collector.rs

@@ -90,10 +90,9 @@ where
 {
     type Fruit = Vec<(TScore, DocAddress)>;
 
-    fn collect(&mut self, doc: DocId, _score: Score) -> crate::Result<()> {
+    fn collect(&mut self, doc: DocId, _score: Score) {
         let score = self.segment_scorer.score(doc);
         self.segment_collector.collect(doc, score);
-        Ok(())
     }
 
     fn harvest(self) -> Vec<(TScore, DocAddress)> {

src/collector/docset_collector.rs

@@ -50,9 +50,8 @@ pub struct DocSetChildCollector {
 impl SegmentCollector for DocSetChildCollector {
     type Fruit = (u32, HashSet<DocId>);
 
-    fn collect(&mut self, doc: crate::DocId, _score: Score) -> crate::Result<()> {
+    fn collect(&mut self, doc: crate::DocId, _score: Score) {
         self.docs.insert(doc);
-        Ok(())
     }
 
     fn harvest(self) -> (u32, HashSet<DocId>) {

src/collector/facet_collector.rs

@@ -333,7 +333,7 @@ impl Collector for FacetCollector {
 impl SegmentCollector for FacetSegmentCollector {
     type Fruit = FacetCounts;
 
-    fn collect(&mut self, doc: DocId, _: Score) -> crate::Result<()> {
+    fn collect(&mut self, doc: DocId, _: Score) {
         self.reader.facet_ords(doc, &mut self.facet_ords_buf);
         let mut previous_collapsed_ord: usize = usize::MAX;
         for &facet_ord in &self.facet_ords_buf {
@@ -345,7 +345,6 @@ impl SegmentCollector for FacetSegmentCollector {
             };
             previous_collapsed_ord = collapsed_ord;
         }
-        Ok(())
     }
 
     /// Returns the results of the collection.

src/collector/filter_collector_wrapper.rs

@@ -173,12 +173,11 @@ where
 {
     type Fruit = TSegmentCollector::Fruit;
 
-    fn collect(&mut self, doc: u32, score: Score) -> crate::Result<()> {
+    fn collect(&mut self, doc: u32, score: Score) {
         let value = self.fast_field_reader.get(doc);
         if (self.predicate)(value) {
-            self.segment_collector.collect(doc, score)?;
+            self.segment_collector.collect(doc, score)
         }
-        Ok(())
     }
 
     fn harvest(self) -> <TSegmentCollector as SegmentCollector>::Fruit {

src/collector/histogram_collector.rs

@@ -91,10 +91,9 @@ pub struct SegmentHistogramCollector {
 impl SegmentCollector for SegmentHistogramCollector {
     type Fruit = Vec<u64>;
 
-    fn collect(&mut self, doc: DocId, _score: Score) -> crate::Result<()> {
+    fn collect(&mut self, doc: DocId, _score: Score) {
         let value = self.ff_reader.get(doc);
         self.histogram_computer.add_value(value);
-        Ok(())
     }
 
     fn harvest(self) -> Self::Fruit {

src/collector/mod.rs

@@ -175,14 +175,12 @@ pub trait Collector: Sync + Send {
         if let Some(alive_bitset) = reader.alive_bitset() {
             weight.for_each(reader, &mut |doc, score| {
                 if alive_bitset.is_alive(doc) {
-                    segment_collector.collect(doc, score)?;
+                    segment_collector.collect(doc, score);
                 }
-                Ok(())
             })?;
         } else {
             weight.for_each(reader, &mut |doc, score| {
-                segment_collector.collect(doc, score)?;
-                Ok(())
+                segment_collector.collect(doc, score);
             })?;
         }
         Ok(segment_collector.harvest())
@@ -192,11 +190,10 @@ pub trait Collector: Sync + Send {
 impl<TSegmentCollector: SegmentCollector> SegmentCollector for Option<TSegmentCollector> {
     type Fruit = Option<TSegmentCollector::Fruit>;
 
-    fn collect(&mut self, doc: DocId, score: Score) -> crate::Result<()> {
+    fn collect(&mut self, doc: DocId, score: Score) {
         if let Some(segment_collector) = self {
-            segment_collector.collect(doc, score)?;
+            segment_collector.collect(doc, score);
         }
-        Ok(())
     }
 
     fn harvest(self) -> Self::Fruit {
@@ -256,7 +253,7 @@ pub trait SegmentCollector: 'static {
     type Fruit: Fruit;
 
     /// The query pushes the scored document to the collector via this method.
-    fn collect(&mut self, doc: DocId, score: Score) -> crate::Result<()>;
+    fn collect(&mut self, doc: DocId, score: Score);
 
     /// Extract the fruit of the collection from the `SegmentCollector`.
     fn harvest(self) -> Self::Fruit;
@@ -311,10 +308,9 @@ where
 {
     type Fruit = (Left::Fruit, Right::Fruit);
 
-    fn collect(&mut self, doc: DocId, score: Score) -> crate::Result<()> {
-        self.0.collect(doc, score)?;
-        self.1.collect(doc, score)?;
-        Ok(())
+    fn collect(&mut self, doc: DocId, score: Score) {
+        self.0.collect(doc, score);
+        self.1.collect(doc, score);
     }
 
     fn harvest(self) -> <Self as SegmentCollector>::Fruit {
@@ -376,11 +372,10 @@ where
 {
     type Fruit = (One::Fruit, Two::Fruit, Three::Fruit);
 
-    fn collect(&mut self, doc: DocId, score: Score) -> crate::Result<()> {
-        self.0.collect(doc, score)?;
-        self.1.collect(doc, score)?;
-        self.2.collect(doc, score)?;
-        Ok(())
+    fn collect(&mut self, doc: DocId, score: Score) {
+        self.0.collect(doc, score);
+        self.1.collect(doc, score);
+        self.2.collect(doc, score);
     }
 
     fn harvest(self) -> <Self as SegmentCollector>::Fruit {
@@ -451,12 +446,11 @@ where
 {
     type Fruit = (One::Fruit, Two::Fruit, Three::Fruit, Four::Fruit);
 
-    fn collect(&mut self, doc: DocId, score: Score) -> crate::Result<()> {
-        self.0.collect(doc, score)?;
-        self.1.collect(doc, score)?;
-        self.2.collect(doc, score)?;
-        self.3.collect(doc, score)?;
-        Ok(())
+    fn collect(&mut self, doc: DocId, score: Score) {
+        self.0.collect(doc, score);
+        self.1.collect(doc, score);
+        self.2.collect(doc, score);
+        self.3.collect(doc, score);
     }
 
     fn harvest(self) -> <Self as SegmentCollector>::Fruit {

src/collector/multi_collector.rs

@@ -52,9 +52,8 @@ impl<TCollector: Collector> Collector for CollectorWrapper<TCollector> {
 impl SegmentCollector for Box<dyn BoxableSegmentCollector> {
     type Fruit = Box<dyn Fruit>;
 
-    fn collect(&mut self, doc: u32, score: Score) -> crate::Result<()> {
-        self.as_mut().collect(doc, score)?;
-        Ok(())
+    fn collect(&mut self, doc: u32, score: Score) {
+        self.as_mut().collect(doc, score);
     }
 
     fn harvest(self) -> Box<dyn Fruit> {
@@ -63,7 +62,7 @@ impl SegmentCollector for Box<dyn BoxableSegmentCollector> {
 }
 
 pub trait BoxableSegmentCollector {
-    fn collect(&mut self, doc: u32, score: Score) -> crate::Result<()>;
+    fn collect(&mut self, doc: u32, score: Score);
     fn harvest_from_box(self: Box<Self>) -> Box<dyn Fruit>;
 }
 
@@ -72,8 +71,8 @@ pub struct SegmentCollectorWrapper<TSegmentCollector: SegmentCollector>(TSegment
 impl<TSegmentCollector: SegmentCollector> BoxableSegmentCollector
     for SegmentCollectorWrapper<TSegmentCollector>
 {
-    fn collect(&mut self, doc: u32, score: Score) -> crate::Result<()> {
-        self.0.collect(doc, score)
+    fn collect(&mut self, doc: u32, score: Score) {
+        self.0.collect(doc, score);
     }
 
     fn harvest_from_box(self: Box<Self>) -> Box<dyn Fruit> {
@@ -229,11 +228,10 @@ pub struct MultiCollectorChild {
 impl SegmentCollector for MultiCollectorChild {
     type Fruit = MultiFruit;
 
-    fn collect(&mut self, doc: DocId, score: Score) -> crate::Result<()> {
+    fn collect(&mut self, doc: DocId, score: Score) {
         for child in &mut self.children {
-            child.collect(doc, score)?;
+            child.collect(doc, score);
         }
-        Ok(())
     }
 
     fn harvest(self) -> MultiFruit {

src/collector/tests.rs

@@ -138,10 +138,9 @@ impl Collector for TestCollector {
 impl SegmentCollector for TestSegmentCollector {
     type Fruit = TestFruit;
 
-    fn collect(&mut self, doc: DocId, score: Score) -> crate::Result<()> {
+    fn collect(&mut self, doc: DocId, score: Score) {
         self.fruit.docs.push(DocAddress::new(self.segment_id, doc));
         self.fruit.scores.push(score);
-        Ok(())
     }
 
     fn harvest(self) -> <Self as SegmentCollector>::Fruit {
@@ -199,10 +198,9 @@ impl Collector for FastFieldTestCollector {
 impl SegmentCollector for FastFieldSegmentCollector {
     type Fruit = Vec<u64>;
 
-    fn collect(&mut self, doc: DocId, _score: Score) -> crate::Result<()> {
+    fn collect(&mut self, doc: DocId, _score: Score) {
         let val = self.reader.get(doc);
         self.vals.push(val);
-        Ok(())
     }
 
     fn harvest(self) -> Vec<u64> {
@@ -257,10 +255,9 @@ impl Collector for BytesFastFieldTestCollector {
 impl SegmentCollector for BytesFastFieldSegmentCollector {
     type Fruit = Vec<u8>;
 
-    fn collect(&mut self, doc: u32, _score: Score) -> crate::Result<()> {
+    fn collect(&mut self, doc: u32, _score: Score) {
         let data = self.reader.get_bytes(doc);
         self.vals.extend(data);
-        Ok(())
     }
 
     fn harvest(self) -> <Self as SegmentCollector>::Fruit {

src/collector/top_score_collector.rs

@@ -699,9 +699,8 @@ pub struct TopScoreSegmentCollector(TopSegmentCollector<Score>);
 impl SegmentCollector for TopScoreSegmentCollector {
     type Fruit = Vec<(Score, DocAddress)>;
 
-    fn collect(&mut self, doc: DocId, score: Score) -> crate::Result<()> {
+    fn collect(&mut self, doc: DocId, score: Score) {
         self.0.collect(doc, score);
-        Ok(())
     }
 
     fn harvest(self) -> Vec<(Score, DocAddress)> {

src/collector/tweak_score_top_collector.rs

@@ -93,10 +93,9 @@ where
 {
     type Fruit = Vec<(TScore, DocAddress)>;
 
-    fn collect(&mut self, doc: DocId, score: Score) -> crate::Result<()> {
+    fn collect(&mut self, doc: DocId, score: Score) {
         let score = self.segment_scorer.score(doc, score);
         self.segment_collector.collect(doc, score);
-        Ok(())
     }
 
     fn harvest(self) -> Vec<(TScore, DocAddress)> {

src/query/boolean_query/boolean_weight.rs

@@ -186,17 +186,17 @@ impl Weight for BooleanWeight {
     fn for_each(
         &self,
         reader: &SegmentReader,
-        callback: &mut dyn FnMut(DocId, Score) -> crate::Result<()>,
+        callback: &mut dyn FnMut(DocId, Score),
     ) -> crate::Result<()> {
         let scorer = self.complex_scorer::<SumWithCoordsCombiner>(reader, 1.0)?;
         match scorer {
             SpecializedScorer::TermUnion(term_scorers) => {
                 let mut union_scorer =
                     Union::<TermScorer, SumWithCoordsCombiner>::from(term_scorers);
-                for_each_scorer(&mut union_scorer, callback)?;
+                for_each_scorer(&mut union_scorer, callback);
             }
             SpecializedScorer::Other(mut scorer) => {
-                for_each_scorer(scorer.as_mut(), callback)?;
+                for_each_scorer(scorer.as_mut(), callback);
             }
         }
         Ok(())

src/query/term_query/term_weight.rs

@@ -49,10 +49,10 @@ impl Weight for TermWeight {
     fn for_each(
         &self,
         reader: &SegmentReader,
-        callback: &mut dyn FnMut(DocId, Score) -> crate::Result<()>,
+        callback: &mut dyn FnMut(DocId, Score),
     ) -> crate::Result<()> {
         let mut scorer = self.specialized_scorer(reader, 1.0)?;
-        for_each_scorer(&mut scorer, callback)?;
+        for_each_scorer(&mut scorer, callback);
         Ok(())
     }
 

src/query/weight.rs

@@ -7,14 +7,13 @@ use crate::{DocId, Score, TERMINATED};
 /// `DocSet` and push the scored documents to the collector.
 pub(crate) fn for_each_scorer<TScorer: Scorer + ?Sized>(
     scorer: &mut TScorer,
-    callback: &mut dyn FnMut(DocId, Score) -> crate::Result<()>,
-) -> crate::Result<()> {
+    callback: &mut dyn FnMut(DocId, Score),
+) {
     let mut doc = scorer.doc();
     while doc != TERMINATED {
-        callback(doc, scorer.score())?;
+        callback(doc, scorer.score());
         doc = scorer.advance();
     }
-    Ok(())
 }
 
 /// Calls `callback` with all of the `(doc, score)` for which score
@@ -72,10 +71,10 @@ pub trait Weight: Send + Sync + 'static {
     fn for_each(
         &self,
         reader: &SegmentReader,
-        callback: &mut dyn FnMut(DocId, Score) -> crate::Result<()>,
+        callback: &mut dyn FnMut(DocId, Score),
     ) -> crate::Result<()> {
         let mut scorer = self.scorer(reader, 1.0)?;
-        for_each_scorer(scorer.as_mut(), callback)?;
+        for_each_scorer(scorer.as_mut(), callback);
         Ok(())
     }