features: Switch no-assert-string feature to descriptive-errors

Replace DekuError::AssertionNoStr with DekuError::Assertion, in concert
with the deku_error!() macro. deku_error!() discards dynamic formatting
when the capability unavailable, usually due to feature selection.
Discarding the unique portion of error strings provides the compiler the
opportunity to coalesce string constants, reducing space required for
.rodata in the spirit of AssertionNoStr.

Introducing descriptive-errors and enabling it by default gives us a
couple of things:

- Maintains the current behaviour where `--features no-assert-string`
  _isn't_ specified,

- What I feel is desirable behaviour if we pass --all-features to `cargo
  build`, where the no-assert-string feature didn't, and

- The ability to control the error message behaviour (though alloc is
  required for descriptive messages)

Demonstrating the impact on wcampbell0x2a/backhand, with
descriptive-errors enabled[^1] we have:

    $ cargo build --release --features="deku/descriptive-errors"
        Finished `release` profile [optimized] target(s) in 0.06s
    $ bloaty -d sections target/release/unsquashfs-backhand | grep '[.]rodata$'
       8.5%   530Ki  10.7%   530Ki    .rodata
    $ readelf --string-dump .rodata target/release/unsquashfs-backhand | grep --color=never --only-matching -E "Field failed assertion.{5}"
    Field failed assertion: Dir
    Field failed assertion: Sup
    Field failed assertion: Sup
    Field failed assertion: Sup
    Field failed assertion: Ext
    Field failed assertion: Bas
    Field failed assertion: Dir
    $

And without:

    $ cargo build --release
        Finished `release` profile [optimized] target(s) in 0.05s
    $ bloaty -d sections target/release/unsquashfs-backhand | grep '[.]rodata$'
       8.5%   529Ki  10.7%   529Ki    .rodata
    $ readelf --string-dump .rodata target/release/unsquashfs-backhand | grep --color=never --only-matching -E "Field failed assertion.{5}"
    Field failed assertionevent
    Field failed assertionCould
    $

[^1]: For the purpose of clarity in the demonstration I temporarily
      changed the patch such that descriptive-errors _isn't_ in the
      default features

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

Author: amboar

CHANGELOG.md

@@ -5,6 +5,7 @@
 ## Added
 
 - The `alloc` feature, allowing use in environments lacking a heap [#582](https://github.com/sharksforarms/deku/pull/582)
+- The `descriptive-errors` feature, replacing `no-assertion-string` [#582](https://github.com/sharksforarms/deku/pull/582)
 
 ## [0.19.1] - 2025-05-22
 

Cargo.toml

@@ -20,12 +20,12 @@ members = [
 ]
 
 [features]
-default = ["std", "bits"]
+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"]
-no-assert-string = ["deku_derive/no-assert-string"]
 bits = ["dep:bitvec", "deku_derive/bits", "alloc" ]
+descriptive-errors = ["alloc"]
 
 [dependencies]
 deku_derive = { version = "^0.19.1", path = "deku-derive", default-features = false}

deku-derive/Cargo.toml

@@ -16,7 +16,6 @@ proc-macro = true
 std = ["proc-macro-crate", "alloc"]
 alloc = []
 logging = []
-no-assert-string = []
 bits = []
 
 [dependencies]

deku-derive/src/macros/mod.rs

@@ -417,13 +417,6 @@ fn assertion_failed(
     } else {
         quote! { stringify!(#v) }
     };
-    #[cfg(feature = "no-assert-string")]
-    {
-        quote! {
-            return Err(::#crate_::DekuError::AssertionNoStr);
-        }
-    }
-    #[cfg(not(feature = "no-assert-string"))]
     {
         quote! {
             return Err(::#crate_::deku_error!(::#crate_::DekuError::Assertion, "Field failed assertion", "{}.{}: {}", #ident, #field_ident_str, #stringify));

src/attributes.rs

@@ -672,12 +672,12 @@ let data: &[u8] = &[0x00, 0x01, 0x02];
 
 let value = DekuTest::try_from(data);
 
-#[cfg(feature = "alloc")]
+#[cfg(feature = "descriptive-errors")]
 assert_eq!(
     Err(DekuError::Assertion("Field failed assertion: DekuTest.data: * data >= 8".into())),
     value
 );
-#[cfg(not(feature = "alloc"))]
+#[cfg(not(feature = "descriptive-errors"))]
 assert_eq!(
     Err(DekuError::Assertion("Field failed assertion".into())),
     value
@@ -717,10 +717,16 @@ value.data = 0x02;
 
 let value: Result<Vec<u8>, DekuError> = value.try_into();
 
+# #[cfg(feature = "descriptive-errors")]
 assert_eq!(
     Err(DekuError::Assertion("Field failed assertion: DekuTest.data: data == 0x01".into())),
     value
 );
+# #[cfg(not(feature = "descriptive-errors"))]
+# assert_eq!(
+#    Err(DekuError::Assertion("Field failed assertion".into())),
+#    value
+# );
 # }
 #
 # #[cfg(not(feature = "alloc"))]

src/error.rs

@@ -1,6 +1,6 @@
 //! Error module
 
-#[cfg(feature = "alloc")]
+#[cfg(feature = "descriptive-errors")]
 use alloc::borrow::Cow;
 
 use no_std_io::io::ErrorKind;
@@ -31,10 +31,10 @@ impl NeedSize {
     }
 }
 
-#[cfg(feature = "alloc")]
+#[cfg(feature = "descriptive-errors")]
 type DekuErrorString = Cow<'static, str>;
 
-#[cfg(not(feature = "alloc"))]
+#[cfg(not(feature = "descriptive-errors"))]
 type DekuErrorString = &'static str;
 
 /// Deku errors
@@ -49,8 +49,6 @@ pub enum DekuError {
     InvalidParam(DekuErrorString),
     /// Assertion error from `assert` or `assert_eq` attributes
     Assertion(DekuErrorString),
-    /// Assertion error from `assert` or `assert_eq` attributes, without string
-    AssertionNoStr,
     /// Could not resolve `id` for variant
     IdVariantNotFound,
     /// IO error while reading or writing
@@ -76,7 +74,7 @@ pub enum DekuError {
 ///                     bit_size,
 ///                     input_size);
 /// ```
-#[cfg(feature = "alloc")]
+#[cfg(feature = "descriptive-errors")]
 #[macro_export]
 macro_rules! deku_error {
     ($p:path, $desc:expr, $fmt:expr, $($arg:expr),*) => {{
@@ -112,7 +110,7 @@ macro_rules! deku_error {
 ///                     bit_size,
 ///                     input_size);
 /// ```
-#[cfg(not(feature = "alloc"))]
+#[cfg(not(feature = "descriptive-errors"))]
 #[macro_export]
 macro_rules! deku_error {
     ($p:path, $desc:expr, $fmt:expr, $($arg:expr),*) => {{
@@ -158,8 +156,7 @@ impl core::fmt::Display for DekuError {
             ),
             DekuError::Parse(ref err) => write!(f, "Parse error: {err}"),
             DekuError::InvalidParam(ref err) => write!(f, "Invalid param error: {err}"),
-            DekuError::Assertion(ref err) => write!(f, "Assertion error: {err}"),
-            DekuError::AssertionNoStr => write!(f, "Assertion error"),
+            DekuError::Assertion(ref err) => write!(f, "{err}"),
             DekuError::IdVariantNotFound => write!(f, "Could not resolve `id` for variant"),
             DekuError::Io(ref e) => write!(f, "io errorr: {e:?}"),
         }
@@ -211,7 +208,6 @@ impl From<DekuError> for std::io::Error {
             DekuError::Parse(_) => io::Error::new(io::ErrorKind::InvalidData, error),
             DekuError::InvalidParam(_) => io::Error::new(io::ErrorKind::InvalidInput, error),
             DekuError::Assertion(_) => io::Error::new(io::ErrorKind::InvalidData, error),
-            DekuError::AssertionNoStr => io::Error::from(io::ErrorKind::InvalidData),
             DekuError::IdVariantNotFound => io::Error::new(io::ErrorKind::NotFound, error),
             DekuError::Io(e) => io::Error::new(e, error),
         }

src/impls/cstring.rs

@@ -1,6 +1,5 @@
-use alloc::borrow::Cow;
 use alloc::ffi::CString;
-use alloc::format;
+
 use alloc::vec::Vec;
 use no_std_io::io::{Read, Seek, Write};
 
@@ -32,7 +31,12 @@ impl DekuReader<'_> for CString {
             Vec::<u8>::from_reader_with_ctx(reader, (Limit::from(|b: &u8| *b == 0x00), ()))?;
 
         let value = CString::from_vec_with_nul(bytes).map_err(|e| {
-            DekuError::Parse(Cow::from(format!("Failed to convert Vec to CString: {e}")))
+            crate::deku_error!(
+                DekuError::Parse,
+                "Failed to convert Vec to CString",
+                "{}",
+                e
+            )
         })?;
 
         Ok(value)
@@ -50,7 +54,12 @@ where
         let bytes = Vec::from_reader_with_ctx(reader, (Limit::from(byte_size.0), ()))?;
 
         let value = CString::from_vec_with_nul(bytes).map_err(|e| {
-            DekuError::Parse(Cow::from(format!("Failed to convert Vec to CString: {e}")))
+            crate::deku_error!(
+                DekuError::Parse,
+                "Failed to convert Vec to CString",
+                "{}",
+                e
+            )
         })?;
 
         Ok(value)
@@ -95,7 +104,7 @@ mod tests {
             b"a",
         ),
 
-        #[should_panic(expected = "Parse(\"Failed to convert Vec to CString: data provided is not nul terminated\")")]
+        #[should_panic(expected = "Failed to convert Vec to CString")]
         case(
             b"test",
             Some(4),

tests/test_bit_container_size.rs

@@ -18,19 +18,19 @@ struct Test {
 
 #[rstest(input,
     #[should_panic(
-        expected = "InvalidParam(\"bit size of input is larger than bit requested size: 5 exceeds 4\")"
+        expected = "bit size of input is larger than bit requested size"
     )]
     case::field_u8_be( Test { field_u8_be: 0b11111, ..Test::default()}),
     #[should_panic(
-        expected = "InvalidParam(\"bit size of input is larger than bit requested size: 5 exceeds 4\")"
+        expected = "bit size of input is larger than bit requested size"
     )]
     case::field_be( Test { field_be: 0b11111, ..Test::default()}),
     #[should_panic(
-        expected = "InvalidParam(\"bit size of input is larger than requested size: 13 exceeds 12\")"
+        expected = "bit size of input is larger than requested size"
     )]
     case::field_le( Test { field_le: 0b1111111111111, ..Test::default()}),
     #[should_panic(
-        expected = "InvalidParam(\"bit size of input is larger than bit requested size: 13 exceeds 9\")"
+        expected = "bit size of input is larger than bit requested size"
     )]
     case::field_u32_be( Test { field_u32_be: 0b1111111111111, ..Test::default()}),
 )]

tests/test_magic.rs

@@ -13,16 +13,16 @@ use rstest::rstest;
 #[rstest(input,
     case(&hex!("64656b75")),
 
-    #[should_panic(expected = "Parse(\"Missing magic value: [100, 101, 107, 117]\")")]
+    #[should_panic(expected = "Missing magic value")]
     case(&hex!("64656bde")),
 
-    #[should_panic(expected = "Parse(\"Missing magic value: [100, 101, 107, 117]\")")]
+    #[should_panic(expected = "Missing magic value")]
     case(&hex!("6465ad75")),
 
-    #[should_panic(expected = "Parse(\"Missing magic value: [100, 101, 107, 117]\")")]
+    #[should_panic(expected = "Missing magic value")]
     case(&hex!("64be6b75")),
 
-    #[should_panic(expected = "Parse(\"Missing magic value: [100, 101, 107, 117]\")")]
+    #[should_panic(expected = "Missing magic value")]
     case(&hex!("ef656b75")),
 
     #[should_panic(expected = "Incomplete(NeedSize { bits: 8 })")]
@@ -44,19 +44,19 @@ fn test_magic_struct(input: &[u8]) {
 #[rstest(input,
     case(&hex!("64656b7500")),
 
-    #[should_panic(expected = "Parse(\"Missing magic value: [100, 101, 107, 117]\")")]
+    #[should_panic(expected = "Missing magic value")]
     case(&hex!("64656bde00")),
 
-    #[should_panic(expected = "Parse(\"Missing magic value: [100, 101, 107, 117]\")")]
+    #[should_panic(expected = "Missing magic value")]
     case(&hex!("6465ad7500")),
 
-    #[should_panic(expected = "Parse(\"Missing magic value: [100, 101, 107, 117]\")")]
+    #[should_panic(expected = "Missing magic value")]
     case(&hex!("64be6b7500")),
 
-    #[should_panic(expected = "Parse(\"Missing magic value: [100, 101, 107, 117]\")")]
+    #[should_panic(expected = "Missing magic value")]
     case(&hex!("ef656b7500")),
 
-    #[should_panic(expected = "Parse(\"Missing magic value: [100, 101, 107, 117]\")")]
+    #[should_panic(expected = "Missing magic value")]
     case(&hex!("64656b00")),
 
     #[should_panic(expected = "Incomplete(NeedSize { bits: 8 })")]