Merge branch 'main' into pr/remove-sized-requirement-for-send-sync-volatile-ref

Author: phil-opp

Changelog.md

@@ -1,5 +1,8 @@
 # Unreleased
 
+- Add implementations for `fmt::Pointer`, `PartialEq`, `Eq`, `PartialOrd`, `Ord` and `Hash`.
+- Update `very_unstable` feature to latest nightly
+
 # 0.5.1 – 2023-06-24
 
 - Fix: Add missing documentation of the `map` macro

src/lib.rs

@@ -38,6 +38,7 @@
 #![cfg_attr(feature = "very_unstable", feature(const_trait_impl))]
 #![cfg_attr(feature = "very_unstable", feature(unboxed_closures))]
 #![cfg_attr(feature = "very_unstable", feature(fn_traits))]
+#![cfg_attr(feature = "very_unstable", feature(effects))]
 #![warn(missing_docs)]
 #![deny(unsafe_op_in_unsafe_fn)]
 

src/volatile_ptr/mod.rs

@@ -1,4 +1,4 @@
-use core::{fmt, marker::PhantomData, ptr::NonNull};
+use core::{cmp::Ordering, fmt, hash, marker::PhantomData, ptr::NonNull};
 
 use crate::access::ReadWrite;
 
@@ -47,12 +47,56 @@ where
 
 impl<T, A> fmt::Debug for VolatilePtr<'_, T, A>
 where
-    T: Copy + fmt::Debug + ?Sized,
+    T: ?Sized,
 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("VolatilePtr")
-            .field("pointer", &self.pointer)
-            .field("access", &self.access)
-            .finish()
+        fmt::Pointer::fmt(&self.pointer.as_ptr(), f)
+    }
+}
+
+impl<T, A> fmt::Pointer for VolatilePtr<'_, T, A>
+where
+    T: ?Sized,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Pointer::fmt(&self.pointer.as_ptr(), f)
+    }
+}
+
+impl<T, A> PartialEq for VolatilePtr<'_, T, A>
+where
+    T: ?Sized,
+{
+    fn eq(&self, other: &Self) -> bool {
+        core::ptr::eq(self.pointer.as_ptr(), other.pointer.as_ptr())
+    }
+}
+
+impl<T, A> Eq for VolatilePtr<'_, T, A> where T: ?Sized {}
+
+impl<T, A> PartialOrd for VolatilePtr<'_, T, A>
+where
+    T: ?Sized,
+{
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(Ord::cmp(&self.pointer.as_ptr(), &other.pointer.as_ptr()))
+    }
+}
+
+impl<T, A> Ord for VolatilePtr<'_, T, A>
+where
+    T: ?Sized,
+{
+    fn cmp(&self, other: &Self) -> Ordering {
+        Ord::cmp(&self.pointer.as_ptr(), &other.pointer.as_ptr())
+    }
+}
+
+impl<T, A> hash::Hash for VolatilePtr<'_, T, A>
+where
+    T: ?Sized,
+{
+    fn hash<H: hash::Hasher>(&self, state: &mut H) {
+        self.pointer.as_ptr().hash(state);
     }
 }

src/volatile_ptr/very_unstable.rs

@@ -16,7 +16,7 @@ where
     /// The safety requirements of [`Self::map`] apply to this method too.
     pub const unsafe fn map_const<F, U>(self, f: F) -> VolatilePtr<'a, U, A>
     where
-        F: ~const FnOnce(NonNull<T>) -> NonNull<U>,
+        F: FnOnce(NonNull<T>) -> NonNull<U>,
         U: ?Sized,
     {
         unsafe { VolatilePtr::new_generic(f(self.pointer)) }
@@ -36,7 +36,7 @@ impl<'a, T, A> VolatilePtr<'a, [T], A> {
         struct Mapper {
             index: usize,
         }
-        impl<T> const FnOnce<(NonNull<[T]>,)> for Mapper {
+        impl<T> FnOnce<(NonNull<[T]>,)> for Mapper {
             type Output = NonNull<T>;
 
             extern "rust-call" fn call_once(self, (slice,): (NonNull<[T]>,)) -> Self::Output {

src/volatile_ref.rs

@@ -2,7 +2,7 @@ use crate::{
     access::{Access, Copyable, ReadOnly, ReadWrite, WriteOnly},
     volatile_ptr::VolatilePtr,
 };
-use core::{fmt, marker::PhantomData, ptr::NonNull};
+use core::{cmp::Ordering, fmt, hash, marker::PhantomData, ptr::NonNull};
 
 /// Volatile pointer type that respects Rust's aliasing rules.
 ///
@@ -12,6 +12,9 @@ use core::{fmt, marker::PhantomData, ptr::NonNull};
 /// - only read-only types implement [`Clone`] and [`Copy`]
 /// - [`Send`] and [`Sync`] are implemented if `T: Sync`
 ///
+/// However, trait implementations like [`fmt::Debug`] and [`Eq`] behave like they do on pointer
+/// types and don't access the referenced value.
+///
 /// To perform volatile operations on `VolatileRef` types, use the [`as_ptr`][Self::as_ptr]
 /// or [`as_mut_ptr`](Self::as_mut_ptr) methods to create a temporary
 /// [`VolatilePtr`][crate::VolatilePtr] instance.
@@ -219,11 +222,7 @@ where
     A: Access + Copyable,
 {
     fn clone(&self) -> Self {
-        Self {
-            pointer: self.pointer,
-            reference: self.reference,
-            access: self.access,
-        }
+        *self
     }
 }
 
@@ -239,12 +238,56 @@ unsafe impl<T, A> Sync for VolatileRef<'_, T, A> where T: Sync + ?Sized {}
 
 impl<T, A> fmt::Debug for VolatileRef<'_, T, A>
 where
-    T: Copy + fmt::Debug + ?Sized,
+    T: ?Sized,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Pointer::fmt(&self.pointer.as_ptr(), f)
+    }
+}
+
+impl<T, A> fmt::Pointer for VolatileRef<'_, T, A>
+where
+    T: ?Sized,
 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("VolatileRef")
-            .field("pointer", &self.pointer)
-            .field("access", &self.access)
-            .finish()
+        fmt::Pointer::fmt(&self.pointer.as_ptr(), f)
+    }
+}
+
+impl<T, A> PartialEq for VolatileRef<'_, T, A>
+where
+    T: ?Sized,
+{
+    fn eq(&self, other: &Self) -> bool {
+        core::ptr::eq(self.pointer.as_ptr(), other.pointer.as_ptr())
+    }
+}
+
+impl<T, A> Eq for VolatileRef<'_, T, A> where T: ?Sized {}
+
+impl<T, A> PartialOrd for VolatileRef<'_, T, A>
+where
+    T: ?Sized,
+{
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(Ord::cmp(&self.pointer.as_ptr(), &other.pointer.as_ptr()))
+    }
+}
+
+impl<T, A> Ord for VolatileRef<'_, T, A>
+where
+    T: ?Sized,
+{
+    fn cmp(&self, other: &Self) -> Ordering {
+        Ord::cmp(&self.pointer.as_ptr(), &other.pointer.as_ptr())
+    }
+}
+
+impl<T, A> hash::Hash for VolatileRef<'_, T, A>
+where
+    T: ?Sized,
+{
+    fn hash<H: hash::Hasher>(&self, state: &mut H) {
+        self.pointer.as_ptr().hash(state);
     }
 }