Fix remaining instances of unsafe

Signed-off-by: Harsha Vamsi Kalluri <[email protected]>

src/core/codec/field_infos/mod.rs

@@ -18,6 +18,7 @@ pub use self::field_infos_format::*;
 use error::ErrorKind::{IllegalArgument, IllegalState};
 use error::Result;
 
+use std::cell::UnsafeCell;
 use std::cmp::max;
 use std::collections::hash_map::Entry;
 use std::collections::{BTreeMap, HashMap};
@@ -108,6 +109,12 @@ impl FieldInfo {
         Ok(info)
     }
 
+    pub unsafe fn get_self(
+        ptr: &UnsafeCell<FieldInfo>,
+    ) -> &mut FieldInfo {
+        unsafe { &mut *ptr.get() }
+    }
+
     pub fn check_consistency(&self) -> Result<()> {
         if let IndexOptions::Null = self.index_options {
             if self.has_store_term_vector {
@@ -324,10 +331,10 @@ pub struct FieldInvertState {
     // we must track these across field instances (multi-valued case)
     pub last_start_offset: i32,
     pub last_position: i32,
-    /*    pub offset_attribute: OffsetAttribute,
-     *    pub pos_incr_attribute: PositionIncrementAttribute,
-     *    pub payload_attribute: PayloadAttribute,
-     *    term_attribute: TermToBytesRefAttribute, */
+    //    pub offset_attribute: OffsetAttribute,
+    //    pub pos_incr_attribute: PositionIncrementAttribute,
+    //    pub payload_attribute: PayloadAttribute,
+    //    term_attribute: TermToBytesRefAttribute,
 }
 
 impl FieldInvertState {

src/core/codec/segment_infos/mod.rs

@@ -21,6 +21,7 @@ pub use self::segment_infos_format::*;
 
 use serde::ser::SerializeStruct;
 use serde::{Serialize, Serializer};
+use std::cell::UnsafeCell;
 use std::collections::{HashMap, HashSet};
 use std::fmt;
 use std::hash::{Hash, Hasher};
@@ -424,6 +425,12 @@ impl<D: Directory, C: Codec> SegmentCommitInfo<D, C> {
         }
     }
 
+    pub unsafe fn get_self(
+        ptr: &UnsafeCell<SegmentCommitInfo<D, C>>,
+    ) -> &mut SegmentCommitInfo<D, C> {
+        unsafe { &mut *ptr.get() }
+    }
+
     pub fn files(&self) -> HashSet<String> {
         let mut files = HashSet::new();
         // Start from the wrapped info's files:

src/core/index/writer/index_writer.rs

@@ -43,9 +43,9 @@ use core::util::to_base36;
 use core::util::{BitsRef, DerefWrapper, DocId, VERSION_LATEST};
 
 use core::index::ErrorKind::MergeAborted;
-use std::cell::UnsafeCell;
 use error::ErrorKind::{AlreadyClosed, IllegalArgument, IllegalState, Index, RuntimeError};
 use error::{Error, Result};
+use std::cell::UnsafeCell;
 
 use std::collections::{HashMap, HashSet, VecDeque};
 use std::mem;
@@ -1070,8 +1070,9 @@ where
 
     #[allow(clippy::mut_from_ref)]
     unsafe fn writer_mut(&self, _l: &MutexGuard<()>) -> &mut IndexWriterInner<D, C, MS, MP> {
-        let writer =
-            self as *const IndexWriterInner<D, C, MS, MP> as *mut IndexWriterInner<D, C, MS, MP> as *const UnsafeCell<IndexWriterInner<D, C, MS, MP>>;
+        let writer = self as *const IndexWriterInner<D, C, MS, MP>
+            as *mut IndexWriterInner<D, C, MS, MP>
+            as *const UnsafeCell<IndexWriterInner<D, C, MS, MP>>;
         unsafe {
             let s = IndexWriterInner::get_self(writer.as_ref().unwrap());
             &mut *s
@@ -4445,6 +4446,13 @@ where
             self.pending_dv_updates.insert(field, v);
         }
     }
+
+    unsafe fn get_self(
+        ptr: &UnsafeCell<ReadersAndUpdatesInner<D, C, MS, MP>>,
+    ) -> &mut ReadersAndUpdatesInner<D, C, MS, MP> {
+        unsafe { &mut *ptr.get() }
+    }
+
     // Writes field updates (new _X_N updates files) to the directory
     // pub fn write_field_updates<DW: Directory>(&mut self, _dir: &DW) -> Result<()> {
     pub fn write_field_updates(&self) -> Result<bool> {
@@ -4454,8 +4462,12 @@ where
         }
 
         let me = unsafe {
-            &mut *(self as *const ReadersAndUpdatesInner<D, C, MS, MP>
-                as *mut ReadersAndUpdatesInner<D, C, MS, MP>)
+            let t = self as *const ReadersAndUpdatesInner<D, C, MS, MP>
+                as *mut ReadersAndUpdatesInner<D, C, MS, MP>
+                as *const UnsafeCell<ReadersAndUpdatesInner<D, C, MS, MP>>;
+            let s = ReadersAndUpdatesInner::get_self(t.as_ref().unwrap());
+
+            &mut *s
         };
 
         assert!(self.reader.is_some());
@@ -4482,7 +4494,10 @@ where
         let mut new_dv_files = me.handle_doc_values_updates(&mut field_infos, doc_values_format)?;
 
         let info_mut_ref = unsafe {
-            &mut *(info.as_ref() as *const SegmentCommitInfo<D, C> as *mut SegmentCommitInfo<D, C>)
+            let t = info.as_ref() as *const SegmentCommitInfo<D, C> as *mut SegmentCommitInfo<D, C>
+                as *const UnsafeCell<SegmentCommitInfo<D, C>>;
+            let s = SegmentCommitInfo::get_self(t.as_ref().unwrap());
+            &mut *s
         };
         // writeFieldInfosGen fnm
         if !new_dv_files.is_empty() {
@@ -4540,7 +4555,12 @@ where
             // step1 construct segment write state
             let ctx = IOContext::Flush(FlushInfo::new(info.info.max_doc() as u32));
             let field_info = infos.field_info_by_name(field).unwrap();
-            let field_info = unsafe { &mut *(field_info as *const FieldInfo as *mut FieldInfo) };
+            let field_info = unsafe {
+                let t = field_info as *const FieldInfo as *mut FieldInfo
+                    as *const UnsafeCell<FieldInfo>;
+                let s: &mut FieldInfo = FieldInfo::get_self(t.as_ref().unwrap());
+                &mut *s
+            };
             let old_dv_gen = field_info.set_doc_values_gen(dv_gen);
             let state = SegmentWriteState::new(
                 tracker.clone(),

src/core/util/doc_id_set.rs

@@ -17,6 +17,7 @@ use core::search::{DocIdSet, DocIterator, NO_MORE_DOCS};
 use core::util::bit_set::{FixedBitSet, ImmutableBitSet};
 use core::util::packed::{EliasFanoDecoder, EliasFanoEncoder, NO_MORE_VALUES};
 use core::util::DocId;
+use std::cell::UnsafeCell;
 use error::ErrorKind::*;
 use std::borrow::Cow;
 use std::sync::Arc;
@@ -361,7 +362,7 @@ impl<DI: DocIterator> DocIterator for NotDocIterator<DI> {
 
 #[derive(Debug)]
 pub struct EliasFanoDocIdSet {
-    ef_encoder:Arc<EliasFanoEncoder>,
+    ef_encoder: Arc<EliasFanoEncoder>,
 }
 
 impl EliasFanoDocIdSet {
@@ -379,9 +380,15 @@ impl EliasFanoDocIdSet {
         EliasFanoEncoder::sufficiently_smaller_than_bit_set(num_values, upper_bound)
     }
 
+    unsafe fn get_self(ptr: &UnsafeCell<EliasFanoEncoder>) -> &mut EliasFanoEncoder {
+        unsafe { &mut *ptr.get() }
+    }
+
     pub fn encode_from_disi(&mut self, mut disi: impl DocIterator) -> Result<()> {
         let encoder = unsafe {
-            &mut *(self.ef_encoder.as_ref() as *const EliasFanoEncoder as *mut EliasFanoEncoder)
+            let s = self.ef_encoder.as_ref() as *const EliasFanoEncoder as *mut EliasFanoEncoder as *const UnsafeCell<EliasFanoEncoder>;
+            let t = EliasFanoDocIdSet::get_self(s.as_ref().unwrap());
+            &mut *t
         };
         while self.ef_encoder.num_encoded < self.ef_encoder.num_values {
             let x = disi.next()?;