docs: fix unused-mut

Signed-off-by: Martin Kröning <[email protected]>

Author: mkroening

src/volatile_ptr/macros.rs

@@ -9,7 +9,7 @@
 ///
 /// 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);
@@ -23,7 +23,7 @@
 /// #[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

@@ -102,7 +102,7 @@ where
     /// use volatile::VolatilePtr;
     ///
     /// 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);
@@ -125,7 +125,7 @@ where
     /// use volatile::VolatilePtr;
     ///
     /// 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,7 +148,7 @@ where
     /// use volatile::VolatilePtr;
     ///
     /// 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();
     ///
@@ -174,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()) };
@@ -187,7 +187,7 @@ where
     /// use volatile::VolatilePtr;
     ///
     /// 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;
@@ -224,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);
@@ -245,7 +245,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.read_only();
     /// assert_eq!(read_only.read(), -4);
@@ -266,10 +266,10 @@ 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 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 @@ where
     /// 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);
@@ -228,7 +228,7 @@ where
     /// 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.read_only();
     /// assert_eq!(read_only.as_ptr().read(), -4);
@@ -250,7 +250,7 @@ where
     /// #[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