Update to compile with latest Rust (part 1)

This change addresses the low-hanging fruit: 1. Update rust-toolchain to a recent nightly. 2. Remove feature flags for invalid features. 3. Update feature usage (mostly MaybeUnInit::get_{ref,mut} and Vec::drain_filter.
msfroh · Jan 31, 2024 · 9095098 · 9095098
1 parent 5b55f84
commit 9095098
Show file tree

Hide file tree

Showing 14 changed files with 57 additions and 60 deletions.
diff --git a/rust-toolchain b/rust-toolchain
@@ -1 +1 @@
-nightly-2020-03-12
+nightly-2024-01-30
diff --git a/src/core/codec/postings/for_util.rs b/src/core/codec/postings/for_util.rs
@@ -132,9 +132,9 @@ impl ForUtilInstance {
             let format = Format::with_id(format_id);
             encoded_sizes[bpv] = encoded_size(format, packed_ints_version, bits_per_value);
             unsafe {
-                decoders.get_mut()[bpv] = get_decoder(format, packed_ints_version, bits_per_value)?;
-                encoders.get_mut()[bpv] = get_encoder(format, packed_ints_version, bits_per_value)?;
-                iterations[bpv] = compute_iterations(&decoders.get_ref()[bpv]);
+                decoders.assume_init_mut()[bpv] = get_decoder(format, packed_ints_version, bits_per_value)?;
+                encoders.assume_init_mut()[bpv] = get_encoder(format, packed_ints_version, bits_per_value)?;
+                iterations[bpv] = compute_iterations(&decoders.assume_init_ref()[bpv]);
             }
         }
 
@@ -168,9 +168,9 @@ impl ForUtilInstance {
             debug_assert!(bits_per_value <= 32);
             encoded_sizes[bpv - 1] = encoded_size(format, VERSION_CURRENT, bits_per_value);
             unsafe {
-                decoders.get_mut()[bpv - 1] = get_decoder(format, VERSION_CURRENT, bits_per_value)?;
-                encoders.get_mut()[bpv - 1] = get_encoder(format, VERSION_CURRENT, bits_per_value)?;
-                iterations[bpv - 1] = compute_iterations(&decoders.get_ref()[bpv - 1]);
+                decoders.assume_init_mut()[bpv - 1] = get_decoder(format, VERSION_CURRENT, bits_per_value)?;
+                encoders.assume_init_mut()[bpv - 1] = get_encoder(format, VERSION_CURRENT, bits_per_value)?;
+                iterations[bpv - 1] = compute_iterations(&decoders.assume_init_ref()[bpv - 1]);
             }
 
             output.write_vint(format.get_id() << 5 | (bits_per_value - 1))?;
@@ -221,7 +221,7 @@ impl ForUtilInstance {
         }
 
         let encoded_size = self.encoded_sizes[num_bits - 1];
-        let decoder = unsafe { &self.decoders.get_ref()[num_bits - 1] };
+        let decoder = unsafe { &self.decoders.assume_init_ref()[num_bits - 1] };
         if let Some(p) = partial_decoder {
             let format = match decoder {
                 &BulkOperationEnum::Packed(_) => Format::Packed,
@@ -410,7 +410,7 @@ impl ForUtil {
         assert!(num_bits > 0 && num_bits <= 32);
 
         let iters = self.instance.iterations[num_bits - 1];
-        let encoder = unsafe { &self.instance.encoders.get_ref()[num_bits - 1] };
+        let encoder = unsafe { &self.instance.encoders.assume_init_ref()[num_bits - 1] };
         assert!(iters * encoder.byte_value_count() as i32 >= BLOCK_SIZE);
         let encoded_size = self.instance.encoded_sizes[num_bits - 1];
         debug_assert!(iters * encoder.byte_block_count() as i32 >= encoded_size);

diff --git a/src/core/codec/postings/terms_hash.rs b/src/core/codec/postings/terms_hash.rs
@@ -262,7 +262,7 @@ where
         let mut all_fields = Vec::with_capacity(field_to_flush.len());
         for (_, f) in field_to_flush {
             unsafe {
-                if !f.base().bytes_hash.get_ref().is_empty() {
+                if !f.base().bytes_hash.assume_init_ref().is_empty() {
                     // TODO: Hack logic, it's because it's hard to gain param `field_to_flush` as
                     // `HashMap<&str, &mut FreqProxTermsWriterPerField>`
                     // this should be fixed later
@@ -472,7 +472,7 @@ where
     fn new(terms_writer: &FreqProxTermsWriterPerField<D, C, MS, MP>) -> Self {
         FreqProxTermsIterator {
             terms_writer,
-            num_terms: unsafe { terms_writer.base.bytes_hash.get_ref().len() },
+            num_terms: unsafe { terms_writer.base.bytes_hash.assume_init_ref().len() },
             ord: -1,
             scratch: BytesRef::default(),
         }
@@ -487,7 +487,7 @@ where
     }
 
     fn set_bytes(&mut self, term_id: usize) {
-        let idx = unsafe { self.terms().base.bytes_hash.get_ref().ids[term_id] as usize };
+        let idx = unsafe { self.terms().base.bytes_hash.assume_init_ref().ids[term_id] as usize };
         let text_start = self.terms().base.postings_array.base.text_starts[idx];
         self.scratch = self
             .terms()
@@ -589,7 +589,7 @@ where
             let mut pos_iter = FreqProxPostingsIterator::new(self.terms());
             unsafe {
                 pos_iter
-                    .reset(self.terms().base.bytes_hash.get_ref().ids[self.ord as usize] as usize);
+                    .reset(self.terms().base.bytes_hash.assume_init_ref().ids[self.ord as usize] as usize);
             }
             Ok(FreqProxPostingIterEnum::Postings(pos_iter))
         } else {
@@ -604,7 +604,7 @@ where
             let mut pos_iter = FreqProxDocsIterator::new(self.terms());
             unsafe {
                 pos_iter
-                    .reset(self.terms().base.bytes_hash.get_ref().ids[self.ord as usize] as usize);
+                    .reset(self.terms().base.bytes_hash.assume_init_ref().ids[self.ord as usize] as usize);
             }
             Ok(FreqProxPostingIterEnum::Docs(pos_iter))
         }

diff --git a/src/core/codec/postings/terms_hash_per_field.rs b/src/core/codec/postings/terms_hash_per_field.rs
@@ -103,7 +103,7 @@ impl<T: PostingsArray + 'static> TermsHashPerFieldBase<T> {
         self.byte_pool = &mut parent.byte_pool;
         self.term_byte_pool = parent.term_byte_pool;
         unsafe {
-            self.bytes_hash.get_mut().pool = parent.term_byte_pool;
+            self.bytes_hash.assume_init_mut().pool = parent.term_byte_pool;
         }
     }
 
@@ -215,7 +215,7 @@ impl<T: PostingsArray + 'static> TermsHashPerFieldBase<T> {
     pub fn sort_postings(&mut self) {
         debug_assert!(self.inited);
         unsafe {
-            self.bytes_hash.get_mut().sort();
+            self.bytes_hash.assume_init_mut().sort();
         }
     }
 
@@ -240,7 +240,7 @@ pub trait TermsHashPerField: Ord + PartialOrd + Eq + PartialEq {
 
     fn reset(&mut self) {
         unsafe {
-            self.base_mut().bytes_hash.get_mut().clear(false);
+            self.base_mut().bytes_hash.assume_init_mut().clear(false);
         }
     }
 
@@ -269,7 +269,7 @@ pub trait TermsHashPerField: Ord + PartialOrd + Eq + PartialEq {
         let term_id = unsafe {
             self.base_mut()
                 .bytes_hash
-                .get_mut()
+                .assume_init_mut()
                 .add_by_pool_offset(text_start)
         };
         self.base_mut().add(term_id);
@@ -293,12 +293,12 @@ pub trait TermsHashPerField: Ord + PartialOrd + Eq + PartialEq {
         // term text into text_start address
         let bytes_ref = BytesRef::new(&token_stream.token().term);
 
-        let term_id = unsafe { self.base_mut().bytes_hash.get_mut().add(&bytes_ref) };
+        let term_id = unsafe { self.base_mut().bytes_hash.assume_init_mut().add(&bytes_ref) };
         if term_id >= 0 {
             unsafe {
                 self.base_mut()
                     .bytes_hash
-                    .get_ref()
+                    .assume_init_ref()
                     .byte_start(term_id as usize);
             }
         }

diff --git a/src/core/codec/term_vectors/term_vector_consumer.rs b/src/core/codec/term_vectors/term_vector_consumer.rs
@@ -641,13 +641,13 @@ where
         }
 
         self.do_vectors = false;
-        let num_postings = unsafe { self.base.bytes_hash.get_ref().len() };
+        let num_postings = unsafe { self.base.bytes_hash.assume_init_ref().len() };
 
         // This is called once, after inverting all occurrences
         // of a given field in the doc.  At this point we flush
         // our hash into the DocWriter.
         unsafe {
-            self.base.bytes_hash.get_mut().sort();
+            self.base.bytes_hash.assume_init_mut().sort();
         }
         match &mut self.term_vectors_writer().0 {
             TermVectorsConsumerEnum::Raw(r) => {
@@ -670,7 +670,7 @@ where
             }
         }
         for j in 0..num_postings {
-            let term_id = unsafe { self.base.bytes_hash.get_ref().ids[j] as usize };
+            let term_id = unsafe { self.base.bytes_hash.assume_init_ref().ids[j] as usize };
             let freq = self.base.postings_array.freqs[term_id];
 
             // Get BytesPtr
@@ -702,7 +702,7 @@ where
 
     fn reset(&mut self) {
         unsafe {
-            self.base.bytes_hash.get_mut().clear(false);
+            self.base.bytes_hash.assume_init_mut().clear(false);
         }
     }
 
@@ -777,14 +777,14 @@ where
         debug_assert_ne!(field.field_type().index_options(), IndexOptions::Null);
         if first {
             unsafe {
-                if !self.base.bytes_hash.get_ref().is_empty() {
+                if !self.base.bytes_hash.assume_init_ref().is_empty() {
                     // Only necessary if previous doc hit a
                     // non-aborting exception while writing vectors in
                     // this field:
                     self.reset();
                 }
 
-                self.base.bytes_hash.get_mut().reinit();
+                self.base.bytes_hash.assume_init_mut().reinit();
             }
             self.has_payloads = false;
             self.do_vectors = field.field_type().store_term_vectors();
@@ -865,7 +865,7 @@ where
     /// RAMOutputStream, which is then quickly flushed to
     /// the real term vectors files in the Directory.
     fn finish(&mut self, _field_state: &FieldInvertState) -> Result<()> {
-        if self.do_vectors && unsafe { !self.base.bytes_hash.get_ref().is_empty() } {
+        if self.do_vectors && unsafe { !self.base.bytes_hash.assume_init_ref().is_empty() } {
             self.term_vectors_writer().add_field_to_flush(self);
         }
         Ok(())

diff --git a/src/core/index/merge/merge_scheduler.rs b/src/core/index/merge/merge_scheduler.rs
@@ -493,7 +493,7 @@ impl<D: Directory + Send + Sync + 'static, C: Codec, MP: MergePolicy> MergeThrea
         let scheduler_mut = unsafe { self.merge_scheduler.inner.scheduler_mut(&l) };
         scheduler_mut
             .merge_tasks
-            .drain_filter(|t| t.merge.id == one_merge.id);
+            .extract_if(|t| t.merge.id == one_merge.id);
         scheduler_mut.update_merge_threads();
         // In case we had stalled indexing, we can now wake up
         // and possibly unstall:

diff --git a/src/core/index/writer/doc_writer_per_thread.rs b/src/core/index/writer/doc_writer_per_thread.rs
@@ -167,7 +167,7 @@ where
         let consumer = DocConsumer::new(self, field_infos);
         self.consumer.write(consumer);
         unsafe {
-            self.consumer.get_mut().init();
+            self.consumer.assume_init_mut().init();
         }
 
         self.inited = true;
@@ -213,7 +213,7 @@ where
         // vs non-aborting exceptions):
         let res = unsafe {
             self.consumer
-                .get_mut()
+                .assume_init_mut()
                 .process_document(&mut self.doc_state, &mut doc)
         };
         self.doc_state.clear();
@@ -273,7 +273,7 @@ where
 
             let res = unsafe {
                 self.consumer
-                    .get_mut()
+                    .assume_init_mut()
                     .process_document(&mut self.doc_state, &mut doc)
             };
             if res.is_err() {
@@ -388,7 +388,7 @@ where
         let mut flush_state = SegmentWriteState::new(
             Arc::clone(&self.directory),
             self.segment_info.clone(),
-            unsafe { self.consumer.get_ref().field_infos.finish()? },
+            unsafe { self.consumer.assume_init_ref().field_infos.finish()? },
             Some(&self.pending_updates),
             ctx,
             "".into(),
@@ -438,11 +438,11 @@ where
 
         // re-init
         unsafe {
-            self.consumer.get_mut().reset_doc_writer(doc_writer);
-            self.consumer.get_mut().init();
+            self.consumer.assume_init_mut().reset_doc_writer(doc_writer);
+            self.consumer.assume_init_mut().init();
         }
 
-        let sort_map = unsafe { self.consumer.get_mut().flush(&mut flush_state)? };
+        let sort_map = unsafe { self.consumer.assume_init_mut().flush(&mut flush_state)? };
         self.pending_updates.deleted_terms.clear();
         self.segment_info
             .set_files(&self.directory.create_files())?;
@@ -596,7 +596,7 @@ where
         debug!("DWPT: now abort");
 
         unsafe {
-            if let Err(e) = self.consumer.get_mut().abort() {
+            if let Err(e) = self.consumer.assume_init_mut().abort() {
                 error!("DefaultIndexChain abort failed by error: '{:?}'", e);
             }
         }

diff --git a/src/core/index/writer/flush_policy.rs b/src/core/index/writer/flush_policy.rs
@@ -183,7 +183,7 @@ impl<C1: Codec, MS1: MergeScheduler, MP1: MergePolicy> FlushPolicy
     {
         if (self.index_write_config.flush_on_doc_count()
             && state.dwpt().num_docs_in_ram >= self.index_write_config.max_buffered_docs())
-            || unsafe { state.dwpt().consumer.get_ref().need_flush() }
+            || unsafe { state.dwpt().consumer.assume_init_ref().need_flush() }
         {
             // Flush this state by num docs
             control.set_flush_pending(state, lg);

diff --git a/src/core/index/writer/index_file_deleter.rs b/src/core/index/writer/index_file_deleter.rs
@@ -488,7 +488,7 @@ impl<D: Directory> IndexFileDeleter<D> {
 
     fn filter_dv_update_files(&self, candidates: &mut Vec<&String>) {
         let dv_update_files: Vec<String> = candidates
-            .drain_filter(|f| -> bool {
+            .extract_if(|f| -> bool {
                 self.fnm_pattern.is_match(f) || self.dv_pattern.is_match(f)
             })
             .map(|f| f.clone())
@@ -502,7 +502,7 @@ impl<D: Directory> IndexFileDeleter<D> {
                 .unwrap()
                 .as_secs();
             to_deletes = old_dv_update_files
-                .drain_filter(|(x, _)| -> bool { *x < tm_now })
+                .extract_if(|(x, _)| -> bool { *x < tm_now })
                 .map(|(_, y)| y)
                 .collect();
             old_dv_update_files.push((tm_now + 60, dv_update_files));

diff --git a/src/core/index/writer/index_writer.rs b/src/core/index/writer/index_writer.rs
@@ -2846,9 +2846,9 @@ where
                 self.segment_infos.remove(info);
                 self.pending_num_docs
                     .fetch_sub(info.info.max_doc as i64, Ordering::AcqRel);
-                if merge.segments.contains(info) {
+                if let Some(pos) = merge.segments.iter().position(|x| *x == *info) {
                     self.merging_segments.remove(&info.info.name);
-                    merge.segments.remove_item(info);
+                    merge.segments.remove(pos);
                 }
                 self.reader_pool.drop(info.as_ref())?;
             }

diff --git a/src/core/search/query/spans/span_near.rs b/src/core/search/query/spans/span_near.rs
@@ -418,11 +418,11 @@ impl<P: PostingIterator> NearSpansUnordered<P> {
 
 impl<P: PostingIterator> ConjunctionSpans<P> for NearSpansUnordered<P> {
     fn conjunction_span_base(&self) -> &ConjunctionSpanBase<P> {
-        unsafe { self.conjunction_span.get_ref() }
+        unsafe { self.conjunction_span.assume_init_ref() }
     }
 
     fn conjunction_span_base_mut(&mut self) -> &mut ConjunctionSpanBase<P> {
-        unsafe { self.conjunction_span.get_mut() }
+        unsafe { self.conjunction_span.assume_init_mut() }
     }
 
     fn two_phase_current_doc_matches(&mut self) -> Result<bool> {
@@ -431,8 +431,8 @@ impl<P: PostingIterator> ConjunctionSpans<P> for NearSpansUnordered<P> {
         loop {
             if self.at_match() {
                 unsafe {
-                    self.conjunction_span.get_mut().first_in_current_doc = true;
-                    self.conjunction_span.get_mut().one_exhausted_in_current_doc = false;
+                    self.conjunction_span.assume_init_mut().first_in_current_doc = true;
+                    self.conjunction_span.assume_init_mut().one_exhausted_in_current_doc = false;
                 }
                 return Ok(true);
             }
@@ -450,8 +450,8 @@ impl<P: PostingIterator> ConjunctionSpans<P> for NearSpansUnordered<P> {
 impl<P: PostingIterator> Spans for NearSpansUnordered<P> {
     fn next_start_position(&mut self) -> Result<i32> {
         unsafe {
-            if self.conjunction_span.get_ref().first_in_current_doc {
-                self.conjunction_span.get_mut().first_in_current_doc = false;
+            if self.conjunction_span.assume_init_ref().first_in_current_doc {
+                self.conjunction_span.assume_init_mut().first_in_current_doc = false;
                 return Ok(self.min_cell().start_position());
             }
         }
@@ -475,7 +475,7 @@ impl<P: PostingIterator> Spans for NearSpansUnordered<P> {
                 == NO_MORE_POSITIONS
             {
                 unsafe {
-                    self.conjunction_span.get_mut().one_exhausted_in_current_doc = true;
+                    self.conjunction_span.assume_init_mut().one_exhausted_in_current_doc = true;
                 }
                 return Ok(NO_MORE_POSITIONS);
             }
@@ -487,9 +487,9 @@ impl<P: PostingIterator> Spans for NearSpansUnordered<P> {
 
     fn start_position(&self) -> i32 {
         unsafe {
-            if self.conjunction_span.get_ref().first_in_current_doc {
+            if self.conjunction_span.assume_init_ref().first_in_current_doc {
                 -1
-            } else if self.conjunction_span.get_ref().one_exhausted_in_current_doc {
+            } else if self.conjunction_span.assume_init_ref().one_exhausted_in_current_doc {
                 NO_MORE_POSITIONS
             } else {
                 self.min_cell().start_position()
@@ -499,9 +499,9 @@ impl<P: PostingIterator> Spans for NearSpansUnordered<P> {
 
     fn end_position(&self) -> i32 {
         unsafe {
-            if self.conjunction_span.get_ref().first_in_current_doc {
+            if self.conjunction_span.assume_init_ref().first_in_current_doc {
                 -1
-            } else if self.conjunction_span.get_ref().one_exhausted_in_current_doc {
+            } else if self.conjunction_span.assume_init_ref().one_exhausted_in_current_doc {
                 NO_MORE_POSITIONS
             } else {
                 self.sub_span_cells[self.max_end_position_cell_idx].end_position()

diff --git a/src/core/util/bits.rs b/src/core/util/bits.rs
@@ -418,7 +418,8 @@ impl<T: LongValues> Bits for SparseBits<T> {
 impl<T: LongValues> BitsMut for SparseBits<T> {
     fn get(&mut self, index: usize) -> Result<bool> {
         unsafe {
-            let ctx = &self.ctx as *const _ as *mut _;
+            //let ctx = &self.ctx as *const _ as *mut _;
+            let ctx = &mut self.ctx as *mut _;
             self.get64(&mut *ctx, index as i64)
         }
     }

diff --git a/src/core/util/doc_id_set.rs b/src/core/util/doc_id_set.rs
@@ -361,7 +361,7 @@ impl<DI: DocIterator> DocIterator for NotDocIterator<DI> {
 
 #[derive(Debug)]
 pub struct EliasFanoDocIdSet {
-    ef_encoder: Arc<EliasFanoEncoder>,
+    ef_encoder:Arc<EliasFanoEncoder>,
 }
 
 impl EliasFanoDocIdSet {