Clippy fix

src/collector/custom_score_top_collector.rs

@@ -58,9 +58,7 @@ where
         segment_local_id: u32,
         segment_reader: &SegmentReader,
     ) -> crate::Result<Self::Child> {
-        let segment_collector = self
-            .collector
-            .for_segment(segment_local_id, segment_reader)?;
+        let segment_collector = self.collector.for_segment(segment_local_id, segment_reader);
         let segment_scorer = self.custom_scorer.segment_scorer(segment_reader)?;
         Ok(CustomScoreTopSegmentCollector {
             segment_collector,

src/collector/top_collector.rs

@@ -120,11 +120,8 @@ where
         &self,
         segment_id: SegmentLocalId,
         _: &SegmentReader,
-    ) -> crate::Result<TopSegmentCollector<F>> {
-        Ok(TopSegmentCollector::new(
-            segment_id,
-            self.limit + self.offset,
-        ))
+    ) -> TopSegmentCollector<F> {
+        TopSegmentCollector::new(segment_id, self.limit + self.offset)
     }
 
     /// Create a new TopCollector with the same limit and offset.

src/collector/top_score_collector.rs

@@ -603,7 +603,7 @@ impl Collector for TopDocs {
         segment_local_id: SegmentLocalId,
         reader: &SegmentReader,
     ) -> crate::Result<Self::Child> {
-        let collector = self.0.for_segment(segment_local_id, reader)?;
+        let collector = self.0.for_segment(segment_local_id, reader);
         Ok(TopScoreSegmentCollector(collector))
     }
 

src/collector/tweak_score_top_collector.rs

@@ -62,9 +62,7 @@ where
         segment_reader: &SegmentReader,
     ) -> Result<Self::Child> {
         let segment_scorer = self.score_tweaker.segment_tweaker(segment_reader)?;
-        let segment_collector = self
-            .collector
-            .for_segment(segment_local_id, segment_reader)?;
+        let segment_collector = self.collector.for_segment(segment_local_id, segment_reader);
         Ok(TopTweakedScoreSegmentCollector {
             segment_collector,
             segment_scorer,

src/core/index.rs

@@ -165,7 +165,8 @@ impl Index {
     fn from_directory(directory: ManagedDirectory, schema: Schema) -> crate::Result<Index> {
         save_new_metas(schema.clone(), &directory)?;
         let metas = IndexMeta::with_schema(schema);
-        Index::create_from_metas(directory, &metas, SegmentMetaInventory::default())
+        let index = Index::create_from_metas(directory, &metas, SegmentMetaInventory::default());
+        Ok(index)
     }
 
     /// Creates a new index given a directory and an `IndexMeta`.
@@ -173,15 +174,15 @@ impl Index {
         directory: ManagedDirectory,
         metas: &IndexMeta,
         inventory: SegmentMetaInventory,
-    ) -> crate::Result<Index> {
+    ) -> Index {
         let schema = metas.schema.clone();
-        Ok(Index {
+        Index {
             directory,
             schema,
             tokenizers: TokenizerManager::default(),
             executor: Arc::new(Executor::single_thread()),
             inventory,
-        })
+        }
     }
 
     /// Accessor for the tokenizer manager.
@@ -256,7 +257,8 @@ impl Index {
         let directory = ManagedDirectory::wrap(directory)?;
         let inventory = SegmentMetaInventory::default();
         let metas = load_metas(&directory, &inventory)?;
-        Index::create_from_metas(directory, &metas, inventory)
+        let index = Index::create_from_metas(directory, &metas, inventory);
+        Ok(index)
     }
 
     /// Reads the index meta file from the directory.

src/core/segment_reader.rs

@@ -178,10 +178,8 @@ impl SegmentReader {
 
         let fast_fields_data = segment.open_read(SegmentComponent::FASTFIELDS)?;
         let fast_fields_composite = CompositeFile::open(&fast_fields_data)?;
-        let fast_field_readers = Arc::new(FastFieldReaders::new(
-            schema.clone(),
-            fast_fields_composite,
-        )?);
+        let fast_field_readers =
+            Arc::new(FastFieldReaders::new(schema.clone(), fast_fields_composite));
 
         let fieldnorm_data = segment.open_read(SegmentComponent::FIELDNORMS)?;
         let fieldnorm_readers = FieldNormReaders::open(fieldnorm_data)?;

src/directory/mmap_directory.rs

@@ -163,8 +163,8 @@ impl MmapDirectoryInner {
         }
     }
 
-    fn watch(&self, callback: WatchCallback) -> crate::Result<WatchHandle> {
-        Ok(self.watcher.watch(callback))
+    fn watch(&self, callback: WatchCallback) -> WatchHandle {
+        self.watcher.watch(callback)
     }
 }
 
@@ -474,7 +474,7 @@ impl Directory for MmapDirectory {
     }
 
     fn watch(&self, watch_callback: WatchCallback) -> crate::Result<WatchHandle> {
-        self.inner.watch(watch_callback)
+        Ok(self.inner.watch(watch_callback))
     }
 }
 

src/fastfield/bytes/writer.rs

@@ -80,7 +80,7 @@ impl BytesFastFieldWriter {
         doc_index_serializer.close_field()?;
         // writing the values themselves
         serializer
-            .new_bytes_fast_field_with_idx(self.field, 1)?
+            .new_bytes_fast_field_with_idx(self.field, 1)
             .write_all(&self.vals)?;
         Ok(())
     }

src/fastfield/readers.rs

@@ -44,14 +44,11 @@ fn type_and_cardinality(field_type: &FieldType) -> Option<(FastType, Cardinality
 }
 
 impl FastFieldReaders {
-    pub(crate) fn new(
-        schema: Schema,
-        fast_fields_composite: CompositeFile,
-    ) -> crate::Result<FastFieldReaders> {
-        Ok(FastFieldReaders {
+    pub(crate) fn new(schema: Schema, fast_fields_composite: CompositeFile) -> FastFieldReaders {
+        FastFieldReaders {
             fast_fields_composite,
             schema,
-        })
+        }
     }
 
     pub(crate) fn space_usage(&self) -> PerFieldSpaceUsage {

src/fastfield/serializer.rs

@@ -66,9 +66,9 @@ impl FastFieldSerializer {
         &mut self,
         field: Field,
         idx: usize,
-    ) -> io::Result<FastBytesFieldSerializer<'_, CountingWriter<WritePtr>>> {
+    ) -> FastBytesFieldSerializer<'_, CountingWriter<WritePtr>> {
         let field_write = self.composite_write.for_field_with_idx(field, idx);
-        FastBytesFieldSerializer::open(field_write)
+        FastBytesFieldSerializer { write: field_write }
     }
 
     /// Closes the serializer
@@ -132,10 +132,6 @@ pub struct FastBytesFieldSerializer<'a, W: Write> {
 }
 
 impl<'a, W: Write> FastBytesFieldSerializer<'a, W> {
-    fn open(write: &'a mut W) -> io::Result<FastBytesFieldSerializer<'a, W>> {
-        Ok(FastBytesFieldSerializer { write })
-    }
-
     pub fn write_all(&mut self, vals: &[u8]) -> io::Result<()> {
         self.write.write_all(vals)
     }

src/indexer/merger.rs

@@ -476,7 +476,7 @@ impl IndexMerger {
             serialize_idx.close_field()?;
         }
 
-        let mut serialize_vals = fast_field_serializer.new_bytes_fast_field_with_idx(field, 1)?;
+        let mut serialize_vals = fast_field_serializer.new_bytes_fast_field_with_idx(field, 1);
         for segment_reader in &self.readers {
             let bytes_reader = segment_reader.fast_fields().bytes(field)
                 .expect("Failed to find bytes field in fast field reader. This is a bug in tantivy. Please report.");

src/postings/serializer.rs

@@ -55,33 +55,17 @@ pub struct InvertedIndexSerializer {
 }
 
 impl InvertedIndexSerializer {
-    /// Open a new `InvertedIndexSerializer` for the given segment
-    fn create(
-        terms_write: CompositeWrite<WritePtr>,
-        postings_write: CompositeWrite<WritePtr>,
-        positions_write: CompositeWrite<WritePtr>,
-        positionsidx_write: CompositeWrite<WritePtr>,
-        schema: Schema,
-    ) -> crate::Result<InvertedIndexSerializer> {
-        Ok(InvertedIndexSerializer {
-            terms_write,
-            postings_write,
-            positions_write,
-            positionsidx_write,
-            schema,
-        })
-    }
-
     /// Open a new `PostingsSerializer` for the given segment
     pub fn open(segment: &mut Segment) -> crate::Result<InvertedIndexSerializer> {
         use crate::SegmentComponent::{POSITIONS, POSITIONSSKIP, POSTINGS, TERMS};
-        InvertedIndexSerializer::create(
-            CompositeWrite::wrap(segment.open_write(TERMS)?),
-            CompositeWrite::wrap(segment.open_write(POSTINGS)?),
-            CompositeWrite::wrap(segment.open_write(POSITIONS)?),
-            CompositeWrite::wrap(segment.open_write(POSITIONSSKIP)?),
-            segment.schema(),
-        )
+        let inv_index_serializer = InvertedIndexSerializer {
+            terms_write: CompositeWrite::wrap(segment.open_write(TERMS)?),
+            postings_write: CompositeWrite::wrap(segment.open_write(POSTINGS)?),
+            positions_write: CompositeWrite::wrap(segment.open_write(POSITIONS)?),
+            positionsidx_write: CompositeWrite::wrap(segment.open_write(POSITIONSSKIP)?),
+            schema: segment.schema(),
+        };
+        Ok(inv_index_serializer)
     }
 
     /// Must be called before starting pushing terms of

src/store/index/mod.rs

@@ -27,7 +27,7 @@ pub struct Checkpoint {
 impl Checkpoint {
     pub(crate) fn follows(&self, other: &Checkpoint) -> bool {
         (self.doc_range.start == other.doc_range.end)
-            && (self.doc_range.start == other.doc_range.end)
+            && (self.byte_range.start == other.byte_range.end)
     }
 }