Enforce unsafe_op_in_unsafe_fn

src/function.rs

@@ -163,7 +163,7 @@ where
         &'this self,
         memo: &memo::Memo<C::Output<'this>>,
     ) -> &'this memo::Memo<C::Output<'this>> {
-        std::mem::transmute(memo)
+        unsafe { std::mem::transmute(memo) }
     }
 
     fn insert_memo<'db>(

src/lib.rs

@@ -1,3 +1,5 @@
+#![forbid(unsafe_op_in_unsafe_fn)]
+
 mod accumulator;
 mod active_query;
 mod array;

src/table.rs

@@ -172,7 +172,7 @@ impl Table {
     /// of the owner of database owning this table.
     pub(crate) unsafe fn memos(&self, id: Id, current_revision: Revision) -> &MemoTable {
         let (page, slot) = split_id(id);
-        self.pages[page.0].memos(slot, current_revision)
+        unsafe { self.pages[page.0].memos(slot, current_revision) }
     }
 
     /// Get the memo table associated with `id`
@@ -194,7 +194,7 @@ impl Table {
     /// of the owner of database owning this table.
     pub(crate) unsafe fn syncs(&self, id: Id, current_revision: Revision) -> &SyncTable {
         let (page, slot) = split_id(id);
-        self.pages[page.0].syncs(slot, current_revision)
+        unsafe { self.pages[page.0].syncs(slot, current_revision) }
     }
 }
 
@@ -297,15 +297,15 @@ impl<T: Slot> TablePage for Page<T> {
     }
 
     unsafe fn memos(&self, slot: SlotIndex, current_revision: Revision) -> &MemoTable {
-        self.get(slot).memos(current_revision)
+        unsafe { self.get(slot).memos(current_revision) }
     }
 
     fn memos_mut(&mut self, slot: SlotIndex) -> &mut MemoTable {
         self.get_mut(slot).memos_mut()
     }
 
     unsafe fn syncs(&self, slot: SlotIndex, current_revision: Revision) -> &SyncTable {
-        self.get(slot).syncs(current_revision)
+        unsafe { self.get(slot).syncs(current_revision) }
     }
 }
 

src/update.rs

@@ -182,7 +182,7 @@ where
 
         let mut changed = false;
         for (old_element, new_element) in old_vec.iter_mut().zip(new_vec) {
-            changed |= T::maybe_update(old_element, new_element);
+            changed |= unsafe { T::maybe_update(old_element, new_element) };
         }
 
         changed
@@ -205,7 +205,7 @@ where
 
         let mut changed = false;
         for (old_element, new_element) in old_vec.iter_mut().zip(new_vec) {
-            changed |= A::Item::maybe_update(old_element, new_element);
+            changed |= unsafe { A::Item::maybe_update(old_element, new_element) };
         }
 
         changed
@@ -276,7 +276,7 @@ macro_rules! maybe_update_map {
             let mut changed = false;
             for (key, new_value) in new_map.into_iter() {
                 let old_value = old_map.get_mut(&key).unwrap();
-                changed |= V::maybe_update(old_value, new_value);
+                changed |= unsafe { V::maybe_update(old_value, new_value) };
             }
             changed
         }
@@ -311,7 +311,7 @@ where
     unsafe fn maybe_update(old_pointer: *mut Self, new_box: Self) -> bool {
         let old_box: &mut Box<T> = unsafe { &mut *old_pointer };
 
-        T::maybe_update(&mut **old_box, *new_box)
+        unsafe { T::maybe_update(&mut **old_box, *new_box) }
     }
 }
 
@@ -325,7 +325,7 @@ where
         if old_box.len() == new_box.len() {
             let mut changed = false;
             for (old_element, new_element) in old_box.iter_mut().zip(new_box) {
-                changed |= T::maybe_update(old_element, new_element);
+                changed |= unsafe { T::maybe_update(old_element, new_element) };
             }
             changed
         } else {
@@ -348,15 +348,15 @@ where
 
         if let Some(inner) = Arc::get_mut(old_arc) {
             match Arc::try_unwrap(new_arc) {
-                Ok(new_inner) => T::maybe_update(inner, new_inner),
+                Ok(new_inner) => unsafe { T::maybe_update(inner, new_inner) },
                 Err(new_arc) => {
                     // We can't unwrap the new arc, so we have to update the old one in place.
                     *old_arc = new_arc;
                     true
                 }
             }
         } else {
-            *old_pointer = new_arc;
+            unsafe { *old_pointer = new_arc };
             true
         }
     }
@@ -367,10 +367,10 @@ where
     T: Update,
 {
     unsafe fn maybe_update(old_pointer: *mut Self, new_vec: Self) -> bool {
-        let old_pointer: *mut T = std::ptr::addr_of_mut!((*old_pointer)[0]);
+        let old_pointer: *mut T = unsafe { std::ptr::addr_of_mut!((*old_pointer)[0]) };
         let mut changed = false;
         for (new_element, i) in new_vec.into_iter().zip(0..) {
-            changed |= T::maybe_update(old_pointer.add(i), new_element);
+            changed |= unsafe { T::maybe_update(old_pointer.add(i), new_element) };
         }
         changed
     }
@@ -384,8 +384,8 @@ where
     unsafe fn maybe_update(old_pointer: *mut Self, new_value: Self) -> bool {
         let old_value = unsafe { &mut *old_pointer };
         match (old_value, new_value) {
-            (Ok(old), Ok(new)) => T::maybe_update(old, new),
-            (Err(old), Err(new)) => E::maybe_update(old, new),
+            (Ok(old), Ok(new)) => unsafe { T::maybe_update(old, new) },
+            (Err(old), Err(new)) => unsafe { E::maybe_update(old, new) },
             (old_value, new_value) => {
                 *old_value = new_value;
                 true
@@ -402,8 +402,8 @@ where
     unsafe fn maybe_update(old_pointer: *mut Self, new_value: Self) -> bool {
         let old_value = unsafe { &mut *old_pointer };
         match (old_value, new_value) {
-            (Either::Left(old), Either::Left(new)) => L::maybe_update(old, new),
-            (Either::Right(old), Either::Right(new)) => R::maybe_update(old, new),
+            (Either::Left(old), Either::Left(new)) => unsafe { L::maybe_update(old, new) },
+            (Either::Right(old), Either::Right(new)) => unsafe { R::maybe_update(old, new) },
             (old_value, new_value) => {
                 *old_value = new_value;
                 true
@@ -417,7 +417,7 @@ macro_rules! fallback_impl {
         $(
             unsafe impl Update for $t {
                 unsafe fn maybe_update(old_pointer: *mut Self, new_value: Self) -> bool {
-                    update_fallback(old_pointer, new_value)
+                    unsafe { update_fallback(old_pointer, new_value) }
                 }
             }
         )*
@@ -489,7 +489,7 @@ where
     unsafe fn maybe_update(old_pointer: *mut Self, new_value: Self) -> bool {
         let old_value = unsafe { &mut *old_pointer };
         match (old_value, new_value) {
-            (Some(old), Some(new)) => T::maybe_update(old, new),
+            (Some(old), Some(new)) => unsafe { T::maybe_update(old, new) },
             (None, None) => false,
             (old_value, new_value) => {
                 *old_value = new_value;

src/views.rs

@@ -169,7 +169,7 @@ where
     /// The underlying type of `caster` must be `ViewCaster::<Db, DbView>`.
     unsafe fn erased_cast(caster: *mut (), db: &dyn Database) -> &DbView {
         let caster = unsafe { &*caster.cast::<ViewCaster<Db, DbView>>() };
-        caster.cast(db)
+        unsafe { caster.cast(db) }
     }
 
     /// The destructor for `Box<ViewCaster<Db, DbView>>`.