Merge pull request #6 from engali94/bug/non-zero

Fix #5 Remove non-zero offset related implementation

Author: engali94

examples/basic_usage.rs

@@ -14,7 +14,6 @@ impl Node {
             self_ref: SelfRef::null(),
         };
 
-        // Set up the self-reference
         node.self_ref.set(&mut node.value).unwrap();
         node
     }

src/error.rs

@@ -12,8 +12,6 @@ pub(crate) enum IntegerOffsetErrorImpl {
     Conversion(isize),
     /// Failed to subtract the two usizes (overflowed isize)
     Sub(usize, usize),
-    /// Got a zero when a non-zero value was expected (for `NonZero*`)
-    InvalidNonZero,
 }
 
 #[cfg(not(feature = "no_std"))]
@@ -34,13 +32,6 @@ mod fmt {
                 IntegerOffsetErrorImpl::Sub(a, b) => {
                     write!(f, "Difference is beween {} and {} overflows `isize`", a, b)
                 }
-
-                IntegerOffsetErrorImpl::InvalidNonZero => {
-                    write!(
-                        f,
-                        "Difference was zero when a `NonZero*` type was specified"
-                    )
-                }
             }
         }
     }

src/offset/integers.rs

@@ -1,7 +1,6 @@
 use super::delta::{Nullable, Offset};
 use crate::error::{IntegerOffsetError, IntegerOffsetErrorImpl};
 use crate::pointer::unreachable::{UncheckedOptionExt, OVERFLOW_SUB};
-use core::num::*;
 
 macro_rules! impl_delta_zeroable {
     ($($type:ty),* $(,)?) => {$(
@@ -41,40 +40,3 @@ macro_rules! impl_delta_zeroable {
 }
 
 impl_delta_zeroable! { i8, i16, i32, i64, i128, isize }
-
-macro_rules! impl_delta_nonzero {
-    ($($type:ident $base:ident),* $(,)?) => {$(
-        unsafe impl Offset for $type {
-            type Error = IntegerOffsetError;
-
-            fn sub(a: *mut u8, b: *mut u8) -> Result<Self, Self::Error> {
-                let del = match isize::checked_sub(a as usize as _, b as usize as _) {
-                    None => return Err(IntegerOffsetError(IntegerOffsetErrorImpl::Sub(a as usize, b as usize))),
-                    Some(0) => return Err(IntegerOffsetError(IntegerOffsetErrorImpl::InvalidNonZero)),
-                    Some(del) => del,
-                };
-
-                if std::mem::size_of::<Self>() < std::mem::size_of::<isize>() && (
-                    ($base::MIN as isize) > del ||
-                    ($base::MAX as isize) < del
-                )
-                {
-                    Err(IntegerOffsetError(IntegerOffsetErrorImpl::Conversion(del)))
-                } else {
-                    // 0 case was checked in match before hand, so this is guarenteed ot be non zero
-                    unsafe { Ok(Self::new_unchecked(del as _)) }
-                }
-            }
-
-            unsafe fn sub_unchecked(a: *mut u8, b: *mut u8) -> Self {
-                Self::new_unchecked(isize::checked_sub(a as usize as _, b as usize as _).unchecked_unwrap(OVERFLOW_SUB) as _)
-            }
-
-            unsafe fn add(self, a: *const u8) -> *mut u8 {
-                <*mut u8>::offset(a as _, self.get() as isize) as *mut u8
-            }
-        }
-    )*};
-}
-
-impl_delta_nonzero! { NonZeroI8 i8, NonZeroI16 i16, NonZeroI32 i32, NonZeroI64 i64, NonZeroI128 i128, NonZeroIsize isize }

src/pointer/self_ref.rs

@@ -59,8 +59,6 @@ fn nn_to_ptr<T: ?Sized>(nn: Ptr<T>) -> *mut T {
 /// the entire structure is always safe - it's only internal layout changes that cause issues.
 ///
 /// Special care needed with packed structs: field reordering during drops can invalidate offsets.
-///
-/// Using `NonZero*` offset types with self-pointing (zero offset) is undefined behavior.
 pub struct SelfRef<T: ?Sized + PointerRecomposition, I: Offset = isize>(
     I,
     MaybeUninit<T::Components>,