Add impl_string! macro and add SmolStr support

Author: AndreyErmilov

Cargo.lock

@@ -42,7 +42,7 @@ zstd = "0.13.0"
 
 [features]
 derive = [ "dep:bitcode_derive" ]
-std = [ "serde?/std", "glam?/std", "arrayvec?/std" ]
+std = [ "serde?/std", "glam?/std", "arrayvec?/std", "smol_str?/std" ]
 default = [ "derive", "std" ]
 
 [package.metadata.docs.rs]

Cargo.toml

@@ -14,7 +14,7 @@ bitcode = { path = "..", features = [ "arrayvec", "rust_decimal", "serde", "smol
 libfuzzer-sys = "0.4"
 rust_decimal = "1.36.0"
 serde = { version ="1.0", features = [ "derive" ] }
-smol_str = "0.3"
+smol_str = { version = "0.3", features = ["serde"] }
 time = { version = "0.3", features = ["serde"]}
 
 # Prevent this from interfering with workspaces

fuzz/Cargo.toml

@@ -31,6 +31,8 @@ macro_rules! impl_both {
 impl_both!(bool, BoolEncoder, BoolDecoder);
 impl_both!(f32, F32Encoder, F32Decoder);
 impl_both!(String, StrEncoder, StrDecoder);
+#[cfg(feature = "smol_str")]
+impl_both!(smol_str::SmolStr, StrEncoder, StrDecoder);
 
 macro_rules! impl_int {
     ($($t:ty),+) => {

src/derive/impls.rs

@@ -17,7 +17,7 @@ mod ip_addr;
 mod map;
 mod option;
 mod result;
-pub(crate) mod smart_ptr;
+mod smart_ptr;
 mod variant;
 pub(crate) mod vec;
 

src/derive/mod.rs

@@ -5,8 +5,6 @@ mod arrayvec;
 mod glam;
 #[cfg(feature = "rust_decimal")]
 mod rust_decimal;
-#[cfg(feature = "smol_str")]
-mod smol_str;
 #[cfg(feature = "time")]
 mod time;
 #[cfg(feature = "uuid")]

src/ext/mod.rs

@@ -5,7 +5,6 @@ use crate::error::err;
 use crate::fast::{NextUnchecked, SliceImpl};
 use crate::length::LengthDecoder;
 use crate::u8_char::U8Char;
-use alloc::borrow::ToOwned;
 use alloc::string::String;
 use alloc::vec::Vec;
 use core::num::NonZeroUsize;
@@ -57,21 +56,37 @@ impl<'b> Encoder<&'b str> for StrEncoder {
     }
 }
 
-impl Encoder<String> for StrEncoder {
-    #[inline(always)]
-    fn encode(&mut self, t: &String) {
-        self.encode(t.as_str());
-    }
+macro_rules! impl_string {
+    ($t:ty) => {
+        impl crate::coder::Encoder<$t> for crate::str::StrEncoder {
+            #[inline(always)]
+            fn encode(&mut self, t: &$t) {
+                self.encode(t.as_str());
+            }
+
+            #[inline(always)]
+            fn encode_vectored<'a>(&mut self, i: impl Iterator<Item = &'a $t> + Clone)
+            where
+                $t: 'a,
+            {
+                self.encode_vectored(i.map(|s| s.as_str()));
+            }
+        }
 
-    #[inline(always)]
-    fn encode_vectored<'a>(&mut self, i: impl Iterator<Item = &'a String> + Clone)
-    where
-        String: 'a,
-    {
-        self.encode_vectored(i.map(String::as_str));
-    }
+        impl<'a> crate::coder::Decoder<'a, $t> for crate::str::StrDecoder<'a> {
+            #[inline(always)]
+            fn decode(&mut self) -> $t {
+                let v: &str = self.decode();
+                <$t>::from(v)
+            }
+        }
+    };
 }
 
+impl_string!(String);
+#[cfg(feature = "smol_str")]
+impl_string!(smol_str::SmolStr);
+
 // Doesn't use VecDecoder because can't decode &[u8].
 #[derive(Default)]
 pub struct StrDecoder<'a> {
@@ -131,14 +146,6 @@ impl<'a> Decoder<'a, &'a str> for StrDecoder<'a> {
     }
 }
 
-impl<'a> Decoder<'a, String> for StrDecoder<'a> {
-    #[inline(always)]
-    fn decode(&mut self) -> String {
-        let v: &str = self.decode();
-        v.to_owned()
-    }
-}
-
 /// Tests 128 bytes a time instead of `<[u8]>::is_ascii` which only tests 8.
 /// 390% faster on 8KB, 27% faster on 1GB (RAM bottleneck).
 fn is_ascii_simd(v: &[u8]) -> bool {
@@ -288,3 +295,26 @@ mod tests2 {
     }
     crate::bench_encode_decode!(str_vec: Vec<String>);
 }
+
+#[cfg(all(test, feature = "smol_str"))]
+mod smol_str_tests {
+    use smol_str::SmolStr;
+
+    /// Short strings stay inline after decode (no heap allocation).
+    #[test]
+    fn decoded_short_string_is_not_heap_allocated() {
+        let s = SmolStr::new("hello");
+        assert!(!s.is_heap_allocated());
+        let decoded: SmolStr = crate::decode(&crate::encode(&s)).unwrap();
+        assert!(!decoded.is_heap_allocated());
+    }
+
+    /// Long strings are heap-allocated after decode.
+    #[test]
+    fn decoded_long_string_is_heap_allocated() {
+        let s = SmolStr::new("this is a longer string that exceeds inline storage");
+        assert!(s.is_heap_allocated());
+        let decoded: SmolStr = crate::decode(&crate::encode(&s)).unwrap();
+        assert!(decoded.is_heap_allocated());
+    }
+}