feat: update edition to 2024

Cargo.toml

@@ -19,7 +19,7 @@ members = [
 resolver = "2"
 
 [workspace.package]
-edition = "2021"
+edition = "2024"
 authors = ["Berrysoft <Strawberry_Str@hotmail.com>"]
 readme = "README.md"
 license = "MIT"

compio-buf/src/io_buf.rs

@@ -49,7 +49,7 @@ pub unsafe trait IoBuf: 'static {
     /// It is static to provide convenience from writing self-referenced
     /// structure.
     unsafe fn as_io_slice(&self) -> IoSlice {
-        IoSlice::from_slice(self.as_slice())
+        unsafe { IoSlice::from_slice(self.as_slice()) }
     }
 
     /// Create an [`IoBuffer`] of this buffer.
@@ -60,11 +60,13 @@ pub unsafe trait IoBuf: 'static {
     /// It is static to provide convenience from writing self-referenced
     /// structure.
     unsafe fn as_io_buffer(&self) -> IoBuffer {
-        IoBuffer::new(
-            self.as_buf_ptr().cast_mut().cast(),
-            self.buf_len(),
-            self.buf_capacity(),
-        )
+        unsafe {
+            IoBuffer::new(
+                self.as_buf_ptr().cast_mut().cast(),
+                self.buf_len(),
+                self.buf_capacity(),
+            )
+        }
     }
 
     /// Returns a view of the buffer with the specified range.
@@ -398,7 +400,7 @@ pub unsafe trait IoBufMut: IoBuf + SetBufInit {
     /// It is static to provide convenience from writing self-referenced
     /// structure.
     unsafe fn as_io_slice_mut(&mut self) -> IoSliceMut {
-        IoSliceMut::from_uninit(self.as_mut_slice())
+        unsafe { IoSliceMut::from_uninit(self.as_mut_slice()) }
     }
 }
 
@@ -474,28 +476,29 @@ pub trait SetBufInit {
     ///
     /// # Safety
     ///
-    /// `len` should be less or equal than `buf_capacity()`.
+    /// * `len` should be less or equal than `buf_capacity()`.
+    /// * The bytes in the range `[buf_len(), len)` must be initialized.
     unsafe fn set_buf_init(&mut self, len: usize);
 }
 
 impl<B: SetBufInit + ?Sized> SetBufInit for &'static mut B {
     unsafe fn set_buf_init(&mut self, len: usize) {
-        (**self).set_buf_init(len)
+        unsafe { (**self).set_buf_init(len) }
     }
 }
 
 impl<B: SetBufInit + ?Sized, #[cfg(feature = "allocator_api")] A: Allocator + 'static> SetBufInit
     for t_alloc!(Box, B, A)
 {
     unsafe fn set_buf_init(&mut self, len: usize) {
-        (**self).set_buf_init(len)
+        unsafe { (**self).set_buf_init(len) }
     }
 }
 
 impl<#[cfg(feature = "allocator_api")] A: Allocator + 'static> SetBufInit for t_alloc!(Vec, u8, A) {
     unsafe fn set_buf_init(&mut self, len: usize) {
         if (**self).buf_len() < len {
-            self.set_len(len);
+            unsafe { self.set_len(len) };
         }
     }
 }
@@ -516,7 +519,7 @@ impl<const N: usize> SetBufInit for [u8; N] {
 impl SetBufInit for bytes::BytesMut {
     unsafe fn set_buf_init(&mut self, len: usize) {
         if (**self).buf_len() < len {
-            self.set_len(len);
+            unsafe { self.set_len(len) };
         }
     }
 }
@@ -535,7 +538,7 @@ impl SetBufInit for std::io::BorrowedBuf<'static> {
 impl<const N: usize> SetBufInit for arrayvec::ArrayVec<u8, N> {
     unsafe fn set_buf_init(&mut self, len: usize) {
         if (**self).buf_len() < len {
-            self.set_len(len);
+            unsafe { self.set_len(len) };
         }
     }
 }
@@ -547,35 +550,35 @@ where
 {
     unsafe fn set_buf_init(&mut self, len: usize) {
         if (**self).buf_len() < len {
-            self.set_len(len);
+            unsafe { self.set_len(len) };
         }
     }
 }
 
 impl<T: IoBufMut> SetBufInit for [T] {
     unsafe fn set_buf_init(&mut self, len: usize) {
-        default_set_buf_init(self.iter_mut(), len)
+        unsafe { default_set_buf_init(self.iter_mut(), len) }
     }
 }
 
 impl<T: IoBufMut, const N: usize> SetBufInit for [T; N] {
     unsafe fn set_buf_init(&mut self, len: usize) {
-        default_set_buf_init(self.iter_mut(), len)
+        unsafe { default_set_buf_init(self.iter_mut(), len) }
     }
 }
 
 impl<T: IoBufMut, #[cfg(feature = "allocator_api")] A: Allocator + 'static> SetBufInit
     for t_alloc!(Vec, T, A)
 {
     unsafe fn set_buf_init(&mut self, len: usize) {
-        default_set_buf_init(self.iter_mut(), len)
+        unsafe { default_set_buf_init(self.iter_mut(), len) }
     }
 }
 
 #[cfg(feature = "arrayvec")]
 impl<T: IoBufMut, const N: usize> SetBufInit for arrayvec::ArrayVec<T, N> {
     unsafe fn set_buf_init(&mut self, len: usize) {
-        default_set_buf_init(self.iter_mut(), len)
+        unsafe { default_set_buf_init(self.iter_mut(), len) }
     }
 }
 
@@ -585,21 +588,26 @@ where
     [T; N]: smallvec::Array<Item = T>,
 {
     unsafe fn set_buf_init(&mut self, len: usize) {
-        default_set_buf_init(self.iter_mut(), len)
+        unsafe { default_set_buf_init(self.iter_mut(), len) }
     }
 }
 
+/// # Safety
+/// * `len` should be less or equal than the sum of `buf_capacity()` of all
+///   buffers.
+/// * The bytes in the range `[buf_len(), new_len)` of each buffer must be
+///   initialized
 unsafe fn default_set_buf_init<'a, B: IoBufMut>(
     iter: impl IntoIterator<Item = &'a mut B>,
     mut len: usize,
 ) {
     for buf in iter {
         let capacity = (*buf).buf_capacity();
         if len >= capacity {
-            buf.set_buf_init(capacity);
+            unsafe { buf.set_buf_init(capacity) };
             len -= capacity;
         } else {
-            buf.set_buf_init(len);
+            unsafe { buf.set_buf_init(len) };
             len = 0;
         }
     }

compio-buf/src/io_slice.rs

@@ -92,7 +92,11 @@ impl IoSlice {
     /// The caller must ensure that, during the lifetime of the `IoSlice`, the
     /// slice is valid the and is not used for mutating.
     pub unsafe fn from_slice(slice: &[u8]) -> Self {
-        Self::new(slice.as_ptr() as _, slice.len())
+        // SAFETY:
+        // - the length is correct
+        // - the content of the buffer is initialized
+        // - the slice is not used for mutating while the `IoSlice` is in use
+        unsafe { Self::new(slice.as_ptr() as _, slice.len()) }
     }
 
     /// Get the pointer to the buffer.
@@ -143,7 +147,10 @@ impl IoSliceMut {
     /// The caller must ensure that, during the lifetime of the `IoSliceMut`,
     /// the slice is valid the and is not used for anything else.
     pub unsafe fn from_slice(slice: &mut [u8]) -> Self {
-        Self::new(slice.as_mut_ptr() as _, slice.len())
+        // SAFETY:
+        // - the length is correct
+        // - the slice is not used for anything else while the `IoSliceMut` is in use
+        unsafe { Self::new(slice.as_mut_ptr() as _, slice.len()) }
     }
 
     /// Create a new `IoSliceMut` from a uninitialized slice.
@@ -152,7 +159,10 @@ impl IoSliceMut {
     /// The caller must ensure that, during the lifetime of the `IoSliceMut`,
     /// the slice is valid the and is not used for anything else.
     pub unsafe fn from_uninit(slice: &mut [MaybeUninit<u8>]) -> Self {
-        Self::new(slice.as_mut_ptr(), slice.len())
+        // SAFETY:
+        // - the length is correct
+        // - the slice is not used for anything else while the `IoSliceMut` is in use
+        unsafe { Self::new(slice.as_mut_ptr(), slice.len()) }
     }
 
     /// Get the pointer to the buffer.

compio-buf/src/io_vec_buf.rs

@@ -24,7 +24,7 @@ pub trait IoVectoredBuf: 'static {
     /// It is static to provide convenience from writing self-referenced
     /// structure.
     unsafe fn io_slices(&self) -> Vec<IoSlice> {
-        self.iter_io_slice().collect()
+        unsafe { self.iter_io_slice() }.collect()
     }
 
     /// An iterator over the [`IoSlice`]s.
@@ -35,7 +35,7 @@ pub trait IoVectoredBuf: 'static {
     /// It is static to provide convenience from writing self-referenced
     /// structure.
     unsafe fn iter_io_slice(&self) -> impl Iterator<Item = IoSlice> {
-        self.iter_io_buffer().map(IoSlice::from)
+        unsafe { self.iter_io_buffer() }.map(IoSlice::from)
     }
 
     /// An iterator over slices.
@@ -86,34 +86,34 @@ pub trait IoVectoredBuf: 'static {
 
 impl<T: IoBuf> IoVectoredBuf for &'static [T] {
     unsafe fn iter_io_buffer(&self) -> impl Iterator<Item = IoBuffer> {
-        self.iter().map(|buf| buf.as_io_buffer())
+        self.iter().map(|buf| unsafe { buf.as_io_buffer() })
     }
 }
 
 impl<T: IoBuf> IoVectoredBuf for &'static mut [T] {
     unsafe fn iter_io_buffer(&self) -> impl Iterator<Item = IoBuffer> {
-        self.iter().map(|buf| buf.as_io_buffer())
+        self.iter().map(|buf| unsafe { buf.as_io_buffer() })
     }
 }
 
 impl<T: IoBuf, const N: usize> IoVectoredBuf for [T; N] {
     unsafe fn iter_io_buffer(&self) -> impl Iterator<Item = IoBuffer> {
-        self.iter().map(|buf| buf.as_io_buffer())
+        self.iter().map(|buf| unsafe { buf.as_io_buffer() })
     }
 }
 
 impl<T: IoBuf, #[cfg(feature = "allocator_api")] A: std::alloc::Allocator + 'static> IoVectoredBuf
     for t_alloc!(Vec, T, A)
 {
     unsafe fn iter_io_buffer(&self) -> impl Iterator<Item = IoBuffer> {
-        self.iter().map(|buf| buf.as_io_buffer())
+        self.iter().map(|buf| unsafe { buf.as_io_buffer() })
     }
 }
 
 #[cfg(feature = "arrayvec")]
 impl<T: IoBuf, const N: usize> IoVectoredBuf for arrayvec::ArrayVec<T, N> {
     unsafe fn iter_io_buffer(&self) -> impl Iterator<Item = IoBuffer> {
-        self.iter().map(|buf| buf.as_io_buffer())
+        self.iter().map(|buf| unsafe { buf.as_io_buffer() })
     }
 }
 
@@ -123,19 +123,19 @@ where
     [T; N]: smallvec::Array<Item = T>,
 {
     unsafe fn iter_io_buffer(&self) -> impl Iterator<Item = IoBuffer> {
-        self.iter().map(|buf| buf.as_io_buffer())
+        self.iter().map(|buf| unsafe { buf.as_io_buffer() })
     }
 }
 
 impl<T: IoBuf, Rest: IoVectoredBuf> IoVectoredBuf for (T, Rest) {
     unsafe fn iter_io_buffer(&self) -> impl Iterator<Item = IoBuffer> {
-        std::iter::once(self.0.as_io_buffer()).chain(self.1.iter_io_buffer())
+        unsafe { std::iter::once(self.0.as_io_buffer()).chain(self.1.iter_io_buffer()) }
     }
 }
 
 impl<T: IoBuf> IoVectoredBuf for (T,) {
     unsafe fn iter_io_buffer(&self) -> impl Iterator<Item = IoBuffer> {
-        std::iter::once(self.0.as_io_buffer())
+        unsafe { std::iter::once(self.0.as_io_buffer()) }
     }
 }
 
@@ -155,7 +155,7 @@ pub trait IoVectoredBufMut: IoVectoredBuf + SetBufInit {
     /// It is static to provide convenience from writing self-referenced
     /// structure.
     unsafe fn io_slices_mut(&mut self) -> Vec<IoSliceMut> {
-        self.iter_io_slice_mut().collect()
+        unsafe { self.iter_io_slice_mut() }.collect()
     }
 
     /// An iterator over the [`IoSliceMut`]s.
@@ -166,7 +166,7 @@ pub trait IoVectoredBufMut: IoVectoredBuf + SetBufInit {
     /// It is static to provide convenience from writing self-referenced
     /// structure.
     unsafe fn iter_io_slice_mut(&mut self) -> impl Iterator<Item = IoSliceMut> {
-        self.iter_io_buffer().map(IoSliceMut::from)
+        unsafe { self.iter_io_buffer() }.map(IoSliceMut::from)
     }
 
     /// An iterator over mutable slices.
@@ -214,14 +214,16 @@ impl<T: IoBufMut, Rest: IoVectoredBufMut> SetBufInit for (T, Rest) {
     unsafe fn set_buf_init(&mut self, len: usize) {
         let buf0_len = std::cmp::min(len, self.0.buf_capacity());
 
-        self.0.set_buf_init(buf0_len);
-        self.1.set_buf_init(len - buf0_len);
+        // SAFETY: buf0_len <= self.0.buf_capacity()
+        unsafe { self.0.set_buf_init(buf0_len) };
+        // SAFETY: propogate
+        unsafe { self.1.set_buf_init(len - buf0_len) };
     }
 }
 
 impl<T: IoBufMut> SetBufInit for (T,) {
     unsafe fn set_buf_init(&mut self, len: usize) {
-        self.0.set_buf_init(len);
+        unsafe { self.0.set_buf_init(len) };
     }
 }
 
@@ -299,7 +301,7 @@ unsafe impl<T: IoVectoredBuf> IoBuf for VectoredBufIter<T> {
 impl<T: IoVectoredBuf + SetBufInit> SetBufInit for VectoredBufIter<T> {
     unsafe fn set_buf_init(&mut self, len: usize) {
         self.cur_filled = len;
-        self.buf.set_buf_init(self.filled + self.cur_filled);
+        unsafe { self.buf.set_buf_init(self.filled + self.cur_filled) };
     }
 }
 

compio-buf/src/slice.rs

@@ -108,7 +108,7 @@ unsafe impl<T: IoBufMut> IoBufMut for Slice<T> {
 
 impl<T: SetBufInit> SetBufInit for Slice<T> {
     unsafe fn set_buf_init(&mut self, len: usize) {
-        self.buffer.set_buf_init(self.begin + len)
+        unsafe { self.buffer.set_buf_init(self.begin + len) }
     }
 }
 
@@ -154,16 +154,15 @@ impl<T> VectoredSlice<T> {
 impl<T: IoVectoredBuf> IoVectoredBuf for VectoredSlice<T> {
     unsafe fn iter_io_buffer(&self) -> impl Iterator<Item = IoBuffer> {
         let mut offset = self.begin;
-        self.buf.iter_io_buffer().filter_map(move |buf| {
+        unsafe { self.buf.iter_io_buffer() }.filter_map(move |buf| {
             let len = buf.len();
             let sub = len.min(offset);
             offset -= sub;
             if len - sub > 0 {
-                Some(IoBuffer::new(
-                    buf.as_ptr().add(sub),
-                    len - sub,
-                    buf.capacity() - sub,
-                ))
+                // SAFETY: sub <= len
+                Some(unsafe {
+                    IoBuffer::new(buf.as_ptr().add(sub), len - sub, buf.capacity() - sub)
+                })
             } else {
                 None
             }
@@ -213,13 +212,14 @@ impl<T> VectoredSliceMut<T> {
 impl<T: IoVectoredBuf> IoVectoredBuf for VectoredSliceMut<T> {
     unsafe fn iter_io_buffer(&self) -> impl Iterator<Item = IoBuffer> {
         let mut offset = self.begin;
-        self.buf.iter_io_buffer().filter_map(move |buf| {
+        unsafe { self.buf.iter_io_buffer() }.filter_map(move |buf| {
             let capacity = buf.capacity();
             let sub = capacity.min(offset);
             offset -= sub;
             if capacity - sub > 0 {
                 let len = buf.len().saturating_sub(sub);
-                Some(IoBuffer::new(buf.as_ptr().add(sub), len, capacity - sub))
+                // SAFETY: sub <= capacity
+                Some(unsafe { IoBuffer::new(buf.as_ptr().add(sub), len, capacity - sub) })
             } else {
                 None
             }
@@ -237,7 +237,7 @@ impl<T> IntoInner for VectoredSliceMut<T> {
 
 impl<T: SetBufInit> SetBufInit for VectoredSliceMut<T> {
     unsafe fn set_buf_init(&mut self, len: usize) {
-        self.buf.set_buf_init(self.begin + len);
+        unsafe { self.buf.set_buf_init(self.begin + len) }
     }
 }
 

compio-buf/src/uninit.rs

@@ -76,7 +76,7 @@ unsafe impl<T: IoBufMut> IoBufMut for Uninit<T> {
 
 impl<T: SetBufInit + IoBuf> SetBufInit for Uninit<T> {
     unsafe fn set_buf_init(&mut self, len: usize) {
-        self.0.set_buf_init(self.0.buf_len() + len);
+        unsafe { self.0.set_buf_init(self.0.buf_len() + len) };
         let inner = self.0.as_inner();
         self.0.set_range(inner.buf_len(), inner.buf_capacity());
     }