Merge pull request #567 from reitermarkus/fix-bytes-feature

Fix `bytes` feature.

Author: reitermarkus

.github/workflows/build.yml

@@ -9,7 +9,7 @@ on:
 
 env:
   CARGO_TERM_COLOR: always
-  RUSTFLAGS: '-D warnings'
+  RUSTFLAGS: "-D warnings"
 
 jobs:
   # Run MIRI tests on nightly
@@ -163,18 +163,25 @@ jobs:
 
       - name: cargo check
         run: |
-          cargo check --target=${{ matrix.target }}
-          cargo check --target=${{ matrix.target }} --features="portable-atomic-critical-section"
-          cargo check --target=${{ matrix.target }} --features="ufmt serde defmt mpmc_large alloc"
+          cargo check --target="${target}"
+          cargo check --target="${target}" --features="alloc"
+
+          # Needs native atomics, since `bytes` doesn't support `portable-atomic`.
+          if [ "${target}" != "riscv32imc-unknown-none-elf" ] && [ "${target}" != "thumbv6m-none-eabi" ]; then
+            cargo check --target="${target}" --features="bytes"
+          fi
+
+          cargo check --target="${target}" --features="defmt"
+          cargo check --target="${target}" --features="mpmc_large"
+          cargo check --target="${target}" --features="portable-atomic-critical-section"
+          cargo check --target="${target}" --features="serde"
+          cargo check --target="${target}" --features="ufmt"
+        env:
+          target: ${{ matrix.target }}
 
   doc:
     name: doc
     runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        target:
-          - x86_64-unknown-linux-gnu
-          - thumbv7m-none-eabi
     steps:
       - name: Checkout
         uses: actions/checkout@v4
@@ -201,14 +208,40 @@ jobs:
             ${{ runner.OS }}-build-${{ hashFiles('**/Cargo.lock') }}
             ${{ runner.OS }}-build-
 
-      - name: Install nightly Rust with target (${{ matrix.target }})
+      - name: Get metadata
+        id: metadata
+        run: |
+          set -euo pipefail
+
+          docsrs_metadata="$(cargo metadata --format-version 1 | jq '.packages[] | select(.name == "heapless") | .metadata.docs.rs')"
+          features=($(jq --raw-output '.features[]' <<< "${docsrs_metadata}"))
+          rustdocflags=(-D warnings --cfg docsrs $(jq --raw-output '.["rustdoc-args"][]' <<< "${docsrs_metadata}"))
+          targets=($(jq --raw-output '.targets[]' <<< "${docsrs_metadata}"))
+
+          echo "features=${features[*]}" >> "${GITHUB_OUTPUT}"
+          echo "rustdocflags=${rustdocflags[*]}" >> "${GITHUB_OUTPUT}"
+          echo "targets=${targets[*]}" >> "${GITHUB_OUTPUT}"
+
+      - name: Install nightly Rust with targets (${{ steps.metadata.outputs.targets }})
         uses: dtolnay/rust-toolchain@nightly
         with:
-          targets: ${{ matrix.target }}
+          targets: ${{ steps.metadata.outputs.targets }}
 
       - name: cargo rustdoc
-        env: {"RUSTDOCFLAGS": "-D warnings --cfg docsrs"}
-        run: cargo rustdoc --target=${{ matrix.target }} --features="ufmt serde defmt mpmc_large portable-atomic-critical-section alloc"
+        run: |
+          set -euo pipefail
+
+          targets=(${targets})
+
+          for target in "${targets[@]}"; do
+            set -x
+            cargo rustdoc --target "${target}" --features "${features}"
+            set +x
+          done
+        env:
+          features: ${{ steps.metadata.outputs.features }}
+          RUSTDOCFLAGS: ${{ steps.metadata.outputs.rustdocflags }}
+          targets: ${{ steps.metadata.outputs.targets }}
 
   # Run cpass tests
   testcpass:
@@ -255,7 +288,7 @@ jobs:
           targets: ${{ matrix.target }}
 
       - name: cargo test
-        run: cargo test --test cpass --target=${{ matrix.target }} --features=serde ${{ matrix.buildtype }}
+        run: cargo test --test cpass --target=${{ matrix.target }} ${{ matrix.buildtype }}
 
   # Run test suite for UI
   testtsan:

CHANGELOG.md

@@ -7,6 +7,18 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
 
+### Changed
+
+- `bytes::BufMut` is now implemented on `VecInner`.
+
+### Fixed
+
+- CI now uses flags specified in `Cargo.toml` for `rustdoc` tests.
+
+### Removed
+
+- Removed invalid `bytes::Buf` implementation.
+
 ## [v0.9.0] - 2025-04-28
 
 ### Added
@@ -90,13 +102,13 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 - The `IndexMapValues` type is now inside the `index_map` module and has been renamed to `Values`.
 - The `IndexMapValuesMut` type is now inside the `index_map` module and has been renamed to `ValuesMut`.
 - The `histbuf` module has been renamed to `history_buf`.
-- The `HistoryBuffer` type has been renamed to `HistoryBuf`. 
-- The `HistoryBufferView` type has been renamed to `HistoryBufView`. 
-- The `OwnedHistBufStorage` type has been renamed to `OwnedHistoryBufStorage`. 
-- The `ViewHistBufStorage` type has been renamed to `ViewHistoryBufStorage`. 
-- The `MpMcQueue` type has been renamed to `Queue`. 
-- The `MpMcQueueView` type has been renamed to `QueueView`. 
-- The `MpMcQueueInner` type has been renamed to `QueueInner`. 
+- The `HistoryBuffer` type has been renamed to `HistoryBuf`.
+- The `HistoryBufferView` type has been renamed to `HistoryBufView`.
+- The `OwnedHistBufStorage` type has been renamed to `OwnedHistoryBufStorage`.
+- The `ViewHistBufStorage` type has been renamed to `ViewHistoryBufStorage`.
+- The `MpMcQueue` type has been renamed to `Queue`.
+- The `MpMcQueueView` type has been renamed to `QueueView`.
+- The `MpMcQueueInner` type has been renamed to `QueueInner`.
 - Remove `Q*` type aliases for `MpMcQueue`, and rename it to just `Queue`
 - Changed `Queue::split` to be `const`.
 

src/bytes.rs

@@ -1,46 +1,22 @@
-//! Bytes implementations for heapless types
+//! Implementations of `bytes` traits for `heapless` types.
 
-use crate::Vec;
-use bytes::{buf::UninitSlice, Buf, BufMut};
+use crate::{
+    len_type::LenType,
+    vec::{VecInner, VecStorage},
+};
+use bytes::{buf::UninitSlice, BufMut};
 
-unsafe impl<const N: usize> Buf for Vec<u8, N> {
-    #[inline]
-    fn remaining(&self) -> usize {
-        self.len()
-    }
-
-    #[inline]
-    fn chunk(&mut self) -> &[u8] {
-        self.as_slice()
-    }
-
-    #[inline]
-    unsafe fn advance(&mut self, cnt: usize) {
-        assert!(
-            cnt <= self.remaining(),
-            "cannot advance past `remaining`: {:?} <= {:?}",
-            cnt,
-            self.remaining(),
-        );
-        unsafe {
-            // SAFETY: We've checked that `cnt` <= `self.remaining()` and we know that
-            // `self.remaining()` <= `self.cap`.
-            self.advance_unchecked(cnt);
-        }
-    }
-}
-
-unsafe impl<const N: usize> BufMut for Vec<u8, N> {
+unsafe impl<S: VecStorage<u8> + ?Sized, LenT: LenType> BufMut for VecInner<u8, LenT, S> {
     #[inline]
     fn remaining_mut(&self) -> usize {
-        N - self.len()
+        self.capacity() - self.len()
     }
 
     #[inline]
     unsafe fn advance_mut(&mut self, cnt: usize) {
         let len = self.len();
         let pos = len + cnt;
-        if pos >= N {
+        if pos >= self.capacity() {
             panic!("Advance out of range");
         }
         self.set_len(pos);
@@ -50,56 +26,56 @@ unsafe impl<const N: usize> BufMut for Vec<u8, N> {
     fn chunk_mut(&mut self) -> &mut UninitSlice {
         let len = self.len();
         let ptr = self.as_mut_ptr();
-        unsafe { &mut UninitSlice::from_raw_parts_mut(ptr, N)[len..] }
+        unsafe { &mut UninitSlice::from_raw_parts_mut(ptr, self.capacity())[len..] }
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use crate::Vec;
+    use crate::{Vec, VecView};
     use bytes::BufMut;
 
     #[test]
     #[should_panic]
-    fn buf_advance_out_of_bounds() {
+    fn buf_mut_advance_mut_out_of_bounds() {
         let mut vec: Vec<u8, 8> = Vec::new();
-        vec.advance(9)
+        unsafe { vec.advance_mut(9) };
     }
 
     #[test]
-    fn buf_remaining() {
+    fn buf_mut_remaining_mut() {
         let mut vec: Vec<u8, 8> = Vec::new();
-        assert_eq!(vec.remaining(), 8);
+        assert_eq!(vec.remaining_mut(), 8);
         vec.push(42).unwrap();
-        assert_eq!(vec.remaining(), 7);
+        assert_eq!(vec.remaining_mut(), 7);
     }
 
     #[test]
-    fn buf_chunk() {
+    fn buf_mut_chunk_mut() {
         let mut vec: Vec<u8, 8> = Vec::new();
-        assert_eq!(vec.chunk().len(), 8);
+        assert_eq!(vec.chunk_mut().len(), 8);
         unsafe { vec.advance_mut(1) };
-        assert_eq!(vec.chunk().len(), 7);
+        assert_eq!(vec.chunk_mut().len(), 7);
     }
 
     #[test]
     #[should_panic]
-    fn buf_mut_advance_mut_out_of_bounds() {
-        let mut vec: Vec<u8, 8> = Vec::new();
+    fn buf_mut_advance_mut_out_of_bounds_view() {
+        let vec: &mut VecView<u8, u8> = &mut Vec::<u8, 8>::new();
         unsafe { vec.advance_mut(9) };
     }
 
     #[test]
-    fn buf_mut_remaining_mut() {
-        let mut vec: Vec<u8, 8> = Vec::new();
+    fn buf_mut_remaining_mut_view() {
+        let vec: &mut VecView<u8, u8> = &mut Vec::<u8, 8>::new();
         assert_eq!(vec.remaining_mut(), 8);
         vec.push(42).unwrap();
         assert_eq!(vec.remaining_mut(), 7);
     }
 
     #[test]
-    fn buf_mut_chunk_mut() {
-        let mut vec: Vec<u8, 8> = Vec::new();
+    fn buf_mut_chunk_mut_view() {
+        let vec: &mut VecView<u8, u8> = &mut Vec::<u8, 8>::new();
         assert_eq!(vec.chunk_mut().len(), 8);
         unsafe { vec.advance_mut(1) };
         assert_eq!(vec.chunk_mut().len(), 7);