docs: remove unused NonNull imports

src/lib.rs

@@ -32,7 +32,7 @@
 //! [in the `unsafe-code-guidelines` repository](https://github.com/rust-lang/unsafe-code-guidelines/issues/411).
 
 #![no_std]
 #![cfg_attr(feature = "unstable", feature(core_intrinsics))]
 #![cfg_attr(feature = "unstable", feature(slice_range))]
 #![cfg_attr(feature = "unstable", feature(slice_ptr_get))]
 #![cfg_attr(feature = "very_unstable", feature(const_trait_impl))]
@@ -41,6 +41,9 @@
 #![cfg_attr(feature = "very_unstable", feature(effects))]
 #![warn(missing_docs)]
 #![deny(unsafe_op_in_unsafe_fn)]
+#![doc(test(attr(deny(warnings))))]
+#![doc(test(attr(allow(dead_code))))]
+#![doc(test(attr(allow(unused_variables))))]
 
 pub use volatile_ptr::VolatilePtr;
 pub use volatile_ref::VolatileRef;

src/volatile_ptr/macros.rs

@@ -6,11 +6,10 @@
 ///
 /// ```
 /// use volatile::{VolatilePtr, map_field};
-/// use core::ptr::NonNull;
 ///
 /// struct Example { field_1: u32, field_2: u8, }
 /// let mut value = Example { field_1: 15, field_2: 255 };
-/// let mut volatile = unsafe { VolatilePtr::new((&mut value).into()) };
+/// let volatile = unsafe { VolatilePtr::new((&mut value).into()) };
 ///
 /// // construct a volatile reference to a field
 /// let field_2 = map_field!(volatile.field_2);
@@ -20,12 +19,11 @@
 /// Creating `VolatilePtr`s to unaligned field in packed structs is not allowed:
 /// ```compile_fail
 /// use volatile::{VolatilePtr, map_field};
-/// use core::ptr::NonNull;
 ///
 /// #[repr(packed)]
 /// struct Example { field_1: u8, field_2: usize, }
 /// let mut value = Example { field_1: 15, field_2: 255 };
-/// let mut volatile = unsafe { VolatilePtr::new((&mut value).into()) };
+/// let volatile = unsafe { VolatilePtr::new((&mut value).into()) };
 ///
 /// // Constructing a volatile reference to an unaligned field doesn't compile.
 /// let field_2 = map_field!(volatile.field_2);

src/volatile_ptr/operations.rs

@@ -100,10 +100,9 @@ where
     ///
     /// ```rust
     /// use volatile::VolatilePtr;
-    /// use core::ptr::NonNull;
     ///
     /// let mut value = 42;
-    /// let mut volatile = unsafe { VolatilePtr::new((&mut value).into()) };
+    /// let volatile = unsafe { VolatilePtr::new((&mut value).into()) };
     /// volatile.write(50);
     ///
     /// assert_eq!(volatile.read(), 50);
@@ -124,10 +123,9 @@ where
     ///
     /// ```rust
     /// use volatile::VolatilePtr;
-    /// use core::ptr::NonNull;
     ///
     /// let mut value = 42;
-    /// let mut volatile = unsafe { VolatilePtr::new((&mut value).into()) };
+    /// let volatile = unsafe { VolatilePtr::new((&mut value).into()) };
     /// volatile.update(|val| val + 1);
     ///
     /// assert_eq!(volatile.read(), 43);
@@ -148,10 +146,9 @@ where
     ///
     /// ```
     /// use volatile::VolatilePtr;
-    /// use core::ptr::NonNull;
     ///
     /// let mut value = 42;
-    /// let mut volatile = unsafe { VolatilePtr::new((&mut value).into()) };
+    /// let volatile = unsafe { VolatilePtr::new((&mut value).into()) };
     /// volatile.write(50);
     /// let unwrapped: *mut i32 = volatile.as_raw_ptr().as_ptr();
     ///
@@ -177,7 +174,7 @@ where
     ///
     /// struct Example { field_1: u32, field_2: u8, }
     /// let mut value = Example { field_1: 15, field_2: 255 };
-    /// let mut volatile = unsafe { VolatilePtr::new((&mut value).into()) };
+    /// let volatile = unsafe { VolatilePtr::new((&mut value).into()) };
     ///
     /// // construct a volatile pointer to a field
     /// let field_2 = unsafe { volatile.map(|ptr| NonNull::new(core::ptr::addr_of_mut!((*ptr.as_ptr()).field_2)).unwrap()) };
@@ -188,10 +185,9 @@ where
     ///
     /// ```
     /// use volatile::VolatilePtr;
-    /// use core::ptr::NonNull;
     ///
     /// let mut value = 5;
-    /// let mut volatile = unsafe { VolatilePtr::new((&mut value).into()) };
+    /// let volatile = unsafe { VolatilePtr::new((&mut value).into()) };
     ///
     /// // DON'T DO THIS:
     /// let mut readout = 0;
@@ -228,7 +224,7 @@ where
     /// use volatile::VolatilePtr;
     ///
     /// let mut value: i16 = -4;
-    /// let mut volatile = unsafe { VolatilePtr::new((&mut value).into()) };
+    /// let volatile = unsafe { VolatilePtr::new((&mut value).into()) };
     ///
     /// let read_only = volatile.restrict::<ReadOnly>();
     /// assert_eq!(read_only.read(), -4);
@@ -247,10 +243,9 @@ where
     ///
     /// ```
     /// use volatile::VolatilePtr;
-    /// use core::ptr::NonNull;
     ///
     /// let mut value: i16 = -4;
-    /// let mut volatile = unsafe { VolatilePtr::new((&mut value).into()) };
+    /// let volatile = unsafe { VolatilePtr::new((&mut value).into()) };
     ///
     /// let read_only = volatile.read_only();
     /// assert_eq!(read_only.read(), -4);
@@ -268,14 +263,13 @@ where
     ///
     /// ```
     /// use volatile::{VolatilePtr, map_field};
-    /// use core::ptr::NonNull;
     ///
     /// struct Example { field_1: u32, field_2: u8, }
     /// let mut value = Example { field_1: 15, field_2: 255 };
-    /// let mut volatile = unsafe { VolatilePtr::new((&mut value).into()) };
+    /// let volatile = unsafe { VolatilePtr::new((&mut value).into()) };
     ///
     /// // construct a volatile write-only pointer to `field_2`
-    /// let mut field_2 = map_field!(volatile.field_2).write_only();
+    /// let field_2 = map_field!(volatile.field_2).write_only();
     /// field_2.write(14);
     /// // field_2.read(); // compile-time error
     /// ```

src/volatile_ptr/unstable.rs

@@ -155,7 +155,7 @@ impl<'a, T, A> VolatilePtr<'a, [T], A> {
     /// let mut dst = [0, 0];
     /// // the `Volatile` type does not work with arrays, so convert `dst` to a slice
     /// let slice = &mut dst[..];
-    /// let mut volatile = unsafe { VolatilePtr::new(NonNull::from(slice)) };
+    /// let volatile = unsafe { VolatilePtr::new(NonNull::from(slice)) };
     /// // Because the slices have to be the same length,
     /// // we slice the source slice from four elements
     /// // to two. It will panic if we don't do this.
@@ -212,8 +212,8 @@ impl<'a, T, A> VolatilePtr<'a, [T], A> {
     /// use core::ptr::NonNull;
     ///
     /// let mut byte_array = *b"Hello, World!";
-    /// let mut slice: &mut [u8] = &mut byte_array[..];
-    /// let mut volatile = unsafe { VolatilePtr::new(NonNull::from(slice)) };
+    /// let slice: &mut [u8] = &mut byte_array[..];
+    /// let volatile = unsafe { VolatilePtr::new(NonNull::from(slice)) };
     /// volatile.copy_within(1..5, 8);
     ///
     /// assert_eq!(&byte_array, b"Hello, Wello!");
@@ -347,7 +347,7 @@ impl<A> VolatilePtr<'_, [u8], A> {
     /// use core::ptr::NonNull;
     ///
     /// let mut vec = vec![0; 10];
-    /// let mut buf = unsafe { VolatilePtr::new(NonNull::from(vec.as_mut_slice())) };
+    /// let buf = unsafe { VolatilePtr::new(NonNull::from(vec.as_mut_slice())) };
     /// buf.fill(1);
     /// assert_eq!(unsafe { buf.as_raw_ptr().as_mut() }, &mut vec![1; 10]);
     /// ```

src/volatile_ref.rs

@@ -207,7 +207,7 @@
     /// use volatile::VolatileRef;
     ///
     /// let mut value: i16 = -4;
-    /// let mut volatile = VolatileRef::from_mut_ref(&mut value);
+    /// let volatile = VolatileRef::from_mut_ref(&mut value);
     ///
     /// let read_only = volatile.restrict::<ReadOnly>();
     /// assert_eq!(read_only.as_ptr().read(), -4);
@@ -226,10 +226,9 @@
     ///
     /// ```
     /// use volatile::VolatileRef;
-    /// use core::ptr::NonNull;
     ///
     /// let mut value: i16 = -4;
-    /// let mut volatile = VolatileRef::from_mut_ref(&mut value);
+    /// let volatile = VolatileRef::from_mut_ref(&mut value);
     ///
     /// let read_only = volatile.read_only();
     /// assert_eq!(read_only.as_ptr().read(), -4);
@@ -247,12 +246,11 @@
     ///
     /// ```
     /// use volatile::{VolatileRef};
-    /// use core::ptr::NonNull;
     ///
     /// #[derive(Clone, Copy)]
     /// struct Example { field_1: u32, field_2: u8, }
     /// let mut value = Example { field_1: 15, field_2: 255 };
-    /// let mut volatile = VolatileRef::from_mut_ref(&mut value);
+    /// let volatile = VolatileRef::from_mut_ref(&mut value);
     ///
     /// let write_only = volatile.write_only();
     /// // write_only.as_ptr().read(); // compile-time error
@@ -316,7 +314,7 @@
     T: ?Sized,
 {
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
         Some(Ord::cmp(&self.pointer.as_ptr(), &other.pointer.as_ptr()))
     }
 }
 
@@ -325,7 +323,7 @@
     T: ?Sized,
 {
     fn cmp(&self, other: &Self) -> Ordering {
         Ord::cmp(&self.pointer.as_ptr(), &other.pointer.as_ptr())
     }
 }