re-use string allocation where possible

Author: conradludgate

usdt-impl/src/common.rs

@@ -171,13 +171,10 @@ fn asm_type_convert(typ: &DataType, input: TokenStream) -> (TokenStream, TokenSt
             // data in a result-like JSON blob, mapping the `Result`'s variants to the keys "ok"
             // and "err".
             quote! {
-                [
-                    match ::usdt::to_json(&#input) {
-                        Ok(json) => format!("{{\"ok\":{}}}", json),
-                        Err(e) => format!("{{\"err\":\"{}\"}}", e.to_string()),
-                    }.as_bytes(),
-                    &[0_u8]
-                ].concat()
+                match ::usdt::to_json(&#input) {
+                    Ok(json) => format!("{{\"ok\":{}}}\0", json).into_bytes(),
+                    Err(e) => format!("{{\"err\":\"{}\"}}\0", e.to_string()).into_bytes(),
+                }
             },
             quote! { .as_ptr() as usize },
         ),
@@ -186,9 +183,7 @@ fn asm_type_convert(typ: &DataType, input: TokenStream) -> (TokenStream, TokenSt
             quote! { .as_ptr() as usize },
         ),
         DataType::Native(dtrace_parser::DataType::String) => (
-            quote! {
-                [(#input.as_ref() as &str).as_bytes(), &[0_u8]].concat()
-            },
+            quote! { ::usdt::SerializeString::serialize(#input) },
             quote! { .as_ptr() as usize },
         ),
         DataType::Native(_) => {
@@ -362,7 +357,7 @@ mod tests {
 
         let expected = quote! {
             let arg_0 = (*<_ as ::std::borrow::Borrow<*const u8>>::borrow(&args.0) as usize);
-            let arg_1 = [(args.1.as_ref() as &str).as_bytes(), &[0_u8]].concat();
+            let arg_1 = { let mut v = Vec::from(args.1); v.push(0); v };
         };
         assert_eq!(args.to_string(), expected.to_string());
 
@@ -404,7 +399,7 @@ mod tests {
         );
         assert_eq!(
             out.to_string(),
-            quote! { [(foo.as_ref() as &str).as_bytes(), &[0_u8]].concat() }.to_string()
+            quote! {{ let mut v = Vec::from(foo); v.push(0); v }}.to_string()
         );
         assert_eq!(post.to_string(), quote! { .as_ptr() as usize }.to_string());
 

usdt-impl/src/lib.rs

@@ -421,6 +421,27 @@ impl Clone for UniqueId {
     }
 }
 
+#[doc(hidden)]
+pub trait SerializeString {
+    fn serialize(self) -> Vec<u8>;
+}
+
+#[doc(hidden)]
+impl<S: AsRef<str> + ?Sized> SerializeString for &S {
+    #[inline]
+    fn serialize(self) -> Vec<u8> {
+        [self.as_ref().as_bytes(), b"0"].concat()
+    }
+}
+
+#[doc(hidden)]
+impl SerializeString for String {
+    fn serialize(mut self) -> Vec<u8> {
+        self.push('\0');
+        self.into_bytes()
+    }
+}
+
 #[cfg(test)]
 mod test {
     use super::*;

usdt/src/lib.rs

@@ -295,7 +295,7 @@ use std::{env, fs};
 
 pub use usdt_attr_macro::provider;
 #[doc(hidden)]
-pub use usdt_impl::to_json;
+pub use usdt_impl::{to_json, SerializeString};
 pub use usdt_impl::{Error, UniqueId};
 pub use usdt_macro::dtrace_provider;