deku: Lift bits feature dependency on alloc

Allow selection of bits feature in no-alloc environments.

Signed-off-by: Andrew Jeffery <andrew@codeconstruct.com.au>

Author: amboar

Cargo.toml

@@ -24,7 +24,7 @@ default = ["std", "bits", "descriptive-errors"]
 std = ["deku_derive/std", "bitvec?/std", "alloc", "no_std_io/std"]
 alloc = ["bitvec?/alloc", "deku_derive/alloc", "no_std_io/alloc" ]
 logging = ["deku_derive/logging", "log"]
-bits = ["dep:bitvec", "deku_derive/bits", "alloc" ]
+bits = ["dep:bitvec", "deku_derive/bits" ]
 descriptive-errors = ["alloc"]
 
 [dependencies]
@@ -60,27 +60,27 @@ manual-unwrap-or-default = "allow"
 
 [[example]]
 name = "custom_reader_and_writer"
-required-features = ["bits"]
+required-features = ["alloc", "bits"]
 
 [[example]]
 name = "deku_input"
 required-features = ["std"]
 
 [[example]]
 name = "enums_catch_all"
-required-features = ["bits"]
+required-features = ["alloc", "bits"]
 
 [[example]]
 name = "enums"
 required-features = ["std"]
 
 [[example]]
 name = "example"
-required-features = ["bits"]
+required-features = ["alloc", "bits"]
 
 [[example]]
 name = "ipv4"
-required-features = ["bits"]
+required-features = ["alloc", "bits"]
 
 [[example]]
 name = "80211"

deku-derive/src/macros/deku_write.rs

@@ -99,7 +99,7 @@ fn emit_struct(input: &DekuData) -> Result<TokenStream, syn::Error> {
 
     // Implement `DekuContainerWrite` for types that don't need a context
     if input.ctx.is_none() || (input.ctx.is_some() && input.ctx_default.is_some()) {
-        #[cfg(feature = "bits")]
+        #[cfg(all(feature = "alloc", feature = "bits"))]
         tokens.extend(quote! {
             #[automatically_derived]
              impl #imp core::convert::TryFrom<#ident> for ::#crate_::bitvec::BitVec<u8, ::#crate_::bitvec::Msb0> #wher {
@@ -357,7 +357,7 @@ fn emit_enum(input: &DekuData) -> Result<TokenStream, syn::Error> {
 
     // Implement `DekuContainerWrite` for types that don't need a context
     if input.ctx.is_none() || (input.ctx.is_some() && input.ctx_default.is_some()) {
-        #[cfg(feature = "bits")]
+        #[cfg(all(feature = "alloc", feature = "bits"))]
         tokens.extend(quote! {
             #[automatically_derived]
              impl #imp core::convert::TryFrom<#ident> for ::#crate_::bitvec::BitVec<u8, ::#crate_::bitvec::Msb0> #wher {

src/attributes.rs

@@ -230,7 +230,7 @@ pub struct BigEndian {
     t: u8,
 }
 
-# #[cfg(feature = "bits")]
+# #[cfg(all(feature = "alloc", feature = "bits"))]
 # fn main() {
 let data = vec![0x10, 0x81];
 let big_endian = BigEndian::try_from(data.as_ref()).unwrap();
@@ -245,7 +245,7 @@ let bytes = big_endian.to_bytes().unwrap();
 assert_eq!(bytes, data);
 # }
 #
-# #[cfg(not(feature = "bits"))]
+# #[cfg(not(all(feature = "alloc", feature = "bits")))]
 # fn main() {}
 ````
 ### Field Example
@@ -261,7 +261,7 @@ pub struct LsbField {
     t: u8,
 }
 
-# #[cfg(feature = "bits")]
+# #[cfg(all(feature = "alloc", feature = "bits"))]
 # fn main() {
 let data = vec![0x40, 0x40];
 let more_first = LsbField::try_from(data.as_ref()).unwrap();
@@ -270,7 +270,7 @@ let bytes = more_first.to_bytes().unwrap();
 assert_eq!(bytes, data);
 # }
 #
-# #[cfg(not(feature = "bits"))]
+# #[cfg(not(all(feature = "alloc", feature = "bits")))]
 # fn main() {}
 ```
 
@@ -1570,7 +1570,7 @@ Specify custom reader or writer tokens for reading a field or variant
 Example:
 ```rust
 use core::convert::{TryInto, TryFrom};
-# #[cfg(feature = "bits")]
+# #[cfg(all(feature = "alloc", feature = "bits"))]
 use deku::bitvec::{BitSlice, BitVec, Msb0};
 use deku::prelude::*;
 

src/impls/cstring.rs

@@ -67,8 +67,8 @@ where
 }
 
 #[cfg(test)]
+#[cfg(all(feature = "alloc", feature = "descriptive-errors"))]
 mod tests {
-    #[cfg(feature = "alloc")]
     use alloc::vec;
     use no_std_io::io::Cursor;
     use rstest::rstest;
@@ -77,7 +77,6 @@ mod tests {
 
     use super::*;
 
-    #[cfg(feature = "alloc")]
     #[rstest(input, len, expected, expected_rest,
         case(
             b"test\0",

src/impls/hashmap.rs

@@ -241,17 +241,16 @@ impl<K: DekuWriter<Ctx>, V: DekuWriter<Ctx>, S, Ctx: Copy> DekuWriter<Ctx> for H
     }
 }
 
+#[cfg(all(feature = "bits", feature = "descriptive-errors"))]
 #[cfg(test)]
 mod tests {
     use no_std_io::io::Cursor;
     use rstest::rstest;
     use rustc_hash::FxHashMap;
 
-    #[cfg(feature = "bits")]
     use crate::reader::Reader;
 
     use super::*;
-    #[cfg(feature = "bits")]
     use bitvec::prelude::*;
 
     // Macro to create a deterministic HashMap for tests
@@ -271,7 +270,6 @@ mod tests {
          };
     );
 
-    #[cfg(feature = "bits")]
     #[rstest(input, endian, bit_size, limit, expected, expected_rest_bits, expected_rest_bytes,
         case::count_0([0xAA].as_ref(), Endian::Little, Some(8), 0.into(), FxHashMap::default(), bits![u8, Msb0;], &[0xaa]),
         case::count_1([0x01, 0xAA, 0x02, 0xBB].as_ref(), Endian::Little, Some(8), 1.into(), fxhashmap!{0x01 => 0xAA}, bits![u8, Msb0;], &[0x02, 0xbb]),

src/impls/hashset.rs

@@ -225,7 +225,7 @@ mod tests {
 
     use super::*;
 
-    #[cfg(feature = "bits")]
+    #[cfg(all(feature = "bits", feature = "descriptive-errors"))]
     #[rstest(input, endian, bit_size, limit, expected, expected_rest_bits, expected_rest_bytes,
         case::count_0([0xAA].as_ref(), Endian::Little, Some(8), 0.into(), FxHashSet::default(), bits![u8, Msb0;], &[0xaa]),
         case::count_1([0xAA, 0xBB].as_ref(), Endian::Little, Some(8), 1.into(), vec![0xAA].into_iter().collect(), bits![u8, Msb0;], &[0xbb]),

src/impls/nonzero.rs

@@ -39,10 +39,10 @@ macro_rules! ImplDekuTraitsCtx {
 macro_rules! ImplDekuTraits {
     ($typ:ty, $readtype:ty) => {
         ImplDekuTraitsCtx!($typ, $readtype, (), ());
-        #[cfg(feature = "bits")]
+        #[cfg(all(feature = "bits", feature = "alloc"))]
         ImplDekuTraitsCtx!($typ, $readtype, (endian, bitsize), (Endian, BitSize));
         ImplDekuTraitsCtx!($typ, $readtype, (endian, bytesize), (Endian, ByteSize));
-        #[cfg(feature = "bits")]
+        #[cfg(all(feature = "bits", feature = "alloc"))]
         ImplDekuTraitsCtx!(
             $typ,
             $readtype,

src/impls/primitive.rs

@@ -444,12 +444,12 @@ macro_rules! ImplDekuReadBytes {
                             <$typ>::from_be_bytes(buf.try_into().unwrap())
                         }
                     }
-                    #[cfg(feature = "bits")]
+                    #[cfg(all(feature = "bits", feature = "alloc"))]
                     ReaderRet::Bits(Some(bits)) => {
                         let a = <$typ>::read(&bits, (endian, size, order))?;
                         a.1
                     }
-                    #[cfg(feature = "bits")]
+                    #[cfg(all(feature = "bits", feature = "alloc"))]
                     ReaderRet::Bits(None) => {
                         return Err(deku_error!(DekuError::Parse, "no bits read from reader"));
                     }
@@ -602,12 +602,12 @@ macro_rules! ImplDekuReadSignExtend {
                             <$typ>::from_be_bytes(buf.try_into().unwrap())
                         }
                     }
-                    #[cfg(feature = "bits")]
+                    #[cfg(all(feature = "bits", feature = "alloc"))]
                     ReaderRet::Bits(Some(bits)) => {
                         let a = <$typ>::read(&bits, (endian, size, order))?;
                         a.1
                     }
-                    #[cfg(feature = "bits")]
+                    #[cfg(all(feature = "bits", feature = "alloc"))]
                     ReaderRet::Bits(None) => {
                         return Err(deku_error!(DekuError::Parse, "no bits read from reader"));
                     }
@@ -1370,7 +1370,7 @@ mod tests {
         native_endian!(-0.006_f64)
     );
 
-    #[cfg(feature = "bits")]
+    #[cfg(all(feature = "bits", feature = "descriptive-errors"))]
     #[rstest(input, endian, bit_size, expected, expected_rest_bits, expected_rest_bytes,
         case::normal([0xDD, 0xCC, 0xBB, 0xAA].as_ref(), Endian::Little, Some(32), 0xAABB_CCDD, bits![u8, Msb0;], &[]),
         case::normal([0xDD, 0xCC, 0xBB, 0xAA].as_ref(), Endian::Big, Some(32), 0xDDCC_BBAA, bits![u8, Msb0;], &[]),
@@ -1412,6 +1412,7 @@ mod tests {
         assert_eq!(expected_rest_bytes, buf);
     }
 
+    #[cfg(feature = "descriptive-errors")]
     #[rstest(input, endian, byte_size, expected, expected_rest_bytes,
         case::normal_be([0xDD, 0xCC, 0xBB, 0xAA].as_ref(), Endian::Big, Some(4), 0xDDCC_BBAA, &[]),
         case::normal_le([0xDD, 0xCC, 0xBB, 0xAA].as_ref(), Endian::Little, Some(4), 0xAABB_CCDD, &[]),
@@ -1448,7 +1449,7 @@ mod tests {
         assert_eq!(expected_rest_bytes, buf);
     }
 
-    #[cfg(feature = "bits")]
+    #[cfg(all(feature = "bits", feature = "descriptive-errors"))]
     #[rstest(input, endian, bit_size, expected, expected_leftover,
         case::normal_le(0xDDCC_BBAA, Endian::Little, None, vec![0xAA, 0xBB, 0xCC, 0xDD], vec![]),
         case::normal_be(0xDDCC_BBAA, Endian::Big, None, vec![0xDD, 0xCC, 0xBB, 0xAA], vec![]),
@@ -1476,6 +1477,7 @@ mod tests {
         assert_eq!(expected, writer.inner.into_inner());
     }
 
+    #[cfg(feature = "descriptive-errors")]
     #[rstest(input, endian, byte_size, expected,
         case::normal_le(0xDDCC_BBAA, Endian::Little, None, vec![0xAA, 0xBB, 0xCC, 0xDD]),
         case::normal_be(0xDDCC_BBAA, Endian::Big, None, vec![0xDD, 0xCC, 0xBB, 0xAA]),

src/impls/vec.rs

@@ -250,7 +250,7 @@ mod tests {
         assert_eq!(expected_rest_bytes, buf);
     }
 
-    #[cfg(feature = "bits")]
+    #[cfg(all(feature = "bits", feature = "descriptive-errors"))]
     #[rstest(input, endian, bit_size, limit, expected, expected_rest_bits, expected_rest_bytes,
         case::count_0([0xAA].as_ref(), Endian::Little, Some(8), 0.into(), vec![], bits![u8, Msb0;], &[0xaa]),
         case::count_1([0xAA, 0xBB].as_ref(), Endian::Little, Some(8), 1.into(), vec![0xAA], bits![u8, Msb0;], &[0xbb]),

src/lib.rs

@@ -35,7 +35,7 @@ but we could also use [from_reader](DekuContainerRead::from_reader).
 ```rust
 use deku::prelude::*;
 
-# #[cfg(feature = "bits")]
+# #[cfg(all(feature = "alloc", feature = "bits"))]
 #[derive(Debug, PartialEq, DekuRead, DekuWrite)]
 #[deku(endian = "big")]
 struct DekuTest {
@@ -46,7 +46,7 @@ struct DekuTest {
     field_c: u16,
 }
 
-# #[cfg(feature = "bits")]
+# #[cfg(all(feature = "alloc", feature = "bits"))]
 # fn main() {
 let data: Vec<u8> = vec![0b0110_1001, 0xBE, 0xEF];
 let (_rest, mut val) = DekuTest::from_bytes((data.as_ref(), 0)).unwrap();
@@ -62,7 +62,7 @@ let data_out = val.to_bytes().unwrap();
 assert_eq!(vec![0b0110_1001, 0xC0, 0xFE], data_out);
 # }
 #
-# #[cfg(not(feature = "bits"))]
+# #[cfg(not(all(feature = "alloc", feature = "bits")))]
 # fn main() {}
 ```
 
@@ -709,7 +709,7 @@ pub trait DekuContainerWrite: DekuWriter<()> {
     /// assert_eq!(deku::bitvec::bitvec![1, 1, 1, 1, 0, 0, 0, 1, 1], bits);
     /// ```
     #[inline(always)]
-    #[cfg(feature = "bits")]
+    #[cfg(all(feature = "bits", feature = "alloc"))]
     fn to_bits(&self) -> Result<bitvec::BitVec<u8, bitvec::Msb0>, DekuError> {
         let mut out_buf = Vec::new();
         let mut cursor = no_std_io::Cursor::new(&mut out_buf);