[WIP] [Help wanted] Adapt to upcoming changes in Abomonation

Cargo.toml

@@ -18,4 +18,4 @@ quote = "1.0"
 synstructure = "0.12"
 
 [dev-dependencies]
-abomonation = "0.7"
+abomonation = { git = "https://github.com/HadrienG2/abomonation.git", branch = "support-more-types" }

src/lib.rs

@@ -14,38 +14,51 @@ fn derive_abomonation(mut s: synstructure::Structure) -> proc_macro2::TokenStrea
     });
 
     let entomb = s.each(|bi| quote! {
-        ::abomonation::Abomonation::entomb(#bi, _write)?;
+        ::abomonation::Entomb::entomb(#bi, _write)?;
     });
 
     let extent = s.each(|bi| quote! {
-        sum += ::abomonation::Abomonation::extent(#bi);
+        sum += ::abomonation::Entomb::extent(#bi);
     });
 
     s.bind_with(|_| synstructure::BindStyle::RefMut);
 
     let exhume = s.each(|bi| quote! {
-        let temp = bytes;
-        bytes = ::abomonation::Abomonation::exhume(#bi, temp)?;
+        bytes = ::abomonation::Exhume::exhume(From::from(#bi), bytes)?;
     });
 
-    s.bound_impl(quote!(abomonation::Abomonation), quote! {
-        #[inline] unsafe fn entomb<W: ::std::io::Write>(&self, _write: &mut W) -> ::std::io::Result<()> {
-            match *self { #entomb }
-            Ok(())
-        }
-        #[allow(unused_mut)]
-        #[inline] fn extent(&self) -> usize {
-            let mut sum = 0;
-            match *self { #extent }
-            sum
+    s.gen_impl(quote! {
+        extern crate abomonation;
+        extern crate std;
+
+        gen unsafe impl abomonation::Entomb for @Self {
+            unsafe fn entomb<W: ::std::io::Write>(&self, _write: &mut W) -> ::std::io::Result<()> {
+                match *self { #entomb }
+                Ok(())
+            }
+
+            #[allow(unused_mut)]
+            fn extent(&self) -> usize {
+                let mut sum = 0;
+                match *self { #extent }
+                sum
+            }
         }
-        #[allow(unused_mut)]
-        #[inline] unsafe fn exhume<'a,'b>(
-            &'a mut self,
-            mut bytes: &'b mut [u8]
-        ) -> Option<&'b mut [u8]> {
-            match *self { #exhume }
-            Some(bytes)
+
+        gen unsafe impl<'de> abomonation::Exhume<'de> for @Self
+            where Self: 'de,
+        {
+            #[allow(unused_mut)]
+            unsafe fn exhume(
+                self_: std::ptr::NonNull<Self>,
+                mut bytes: &'de mut [u8]
+            ) -> Option<&'de mut [u8]> {
+                // FIXME: This (briefly) constructs an &mut _ to invalid data
+                //        (via "ref mut"), which is UB. The proposed &raw mut
+                //        operator would allow avoiding this.
+                match *self_.as_ptr() { #exhume }
+                Some(bytes)
+            }
         }
     })
 }

tests/test.rs

@@ -202,4 +202,25 @@ mod tests {
             assert!(rest.len() == 0);
         }
     }
+
+    #[derive(Eq, PartialEq, Abomonation)]
+    pub struct StructWithRef<'a> {
+        a: &'a str,
+        b: bool,
+    }
+
+    #[test]
+    fn test_struct_with_ref() {
+        let record = StructWithRef { a: &"test", b: true };
+
+        let mut bytes = Vec::new();
+        unsafe { encode(&record, &mut bytes).unwrap(); }
+
+        assert_eq!(bytes.len(), measure(&record));
+
+        if let Some((result, rest)) = unsafe { decode::<StructWithRef>(&mut bytes) } {
+            assert!(result == &record);
+            assert!(rest.len() == 0);
+        }
+    }
 }