[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 = "alignment" }

src/lib.rs

@@ -1,7 +1,8 @@
 #![recursion_limit="128"]
 
-use synstructure::decl_derive;
 use quote::quote;
+use std::collections::HashSet;
+use synstructure::decl_derive;
 
 decl_derive!([Abomonation, attributes(unsafe_abomonate_ignore)] => derive_abomonation);
 
@@ -14,38 +15,77 @@ 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);
-    });
+    // T::alignment() is the max of mem::align_of<T> and the U::alignment()s of
+    // every U type used as a struct member or inside of an enum variant (which
+    // includes the alignment of recursively abomonated data)
+    //
+    // Unfortunately, we cannot use synstructure's nice `fold()` convenience
+    // here because it's based on generating match arms for a `self` value,
+    // whereas here we're trying to implement an inherent type method without
+    // having such a `self` handy.
+    //
+    // We can, however, use Structure::variants() and VariantInfo::bindings()
+    // to enumerate all the types which _would appear_ in such match arms'
+    // inner bindings.
+    //
+    let mut alignment = vec![
+        quote!(let mut align = ::std::mem::align_of::<Self>();)
+    ];
+    let mut probed_types = HashSet::new();
+    for variant_info in s.variants() {
+        for binding_info in variant_info.bindings() {
+            let binding_type = &binding_info.ast().ty;
+            // Do not query a type's alignment() multiple times
+            if probed_types.insert(binding_type) {
+                alignment.push(
+                    quote!(align = align.max(<#binding_type as ::abomonation::Entomb>::alignment());)
+                );
+            }
+        }
+    }
+    alignment.push(quote!(align));
 
     s.bind_with(|_| synstructure::BindStyle::RefMut);
 
     let exhume = s.each(|bi| quote! {
-        let temp = bytes;
-        bytes = ::abomonation::Abomonation::exhume(#bi, temp)?;
+        ::abomonation::Exhume::exhume(From::from(#bi), reader)?;
     });
 
-    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 ::abomonation::align::AlignedWriter<W>
+            ) -> ::std::io::Result<()> {
+                match *self { #entomb }
+                Ok(())
+            }
+
+            fn alignment() -> usize {
+                #(#alignment)*
+            }
         }
-        #[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>,
+                reader: &mut ::abomonation::align::AlignedReader<'de>
+            ) -> Option<&'de mut Self> {
+                // 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(&mut *self_.as_ptr())
+            }
         }
     })
 }

tests/test.rs

@@ -6,6 +6,7 @@ extern crate abomonation_derive;
 #[cfg(test)]
 mod tests {
     use abomonation::*;
+    use abomonation::align::AlignedBytes;
 
     #[derive(Eq, PartialEq, Abomonation)]
     pub struct Struct {
@@ -26,6 +27,7 @@ mod tests {
         assert_eq!(bytes.len(), measure(&record));
 
         // decode from binary data
+        let mut bytes = AlignedBytes::<Struct>::new(&mut bytes);
         if let Some((result, rest)) = unsafe { decode::<Struct>(&mut bytes) } {
             assert!(result == &record);
             assert!(rest.len() == 0);
@@ -47,6 +49,7 @@ mod tests {
         assert_eq!(bytes.len(), measure(&record));
 
         // decode from binary data
+        let mut bytes = AlignedBytes::<EmptyStruct>::new(&mut bytes);
         if let Some((result, rest)) = unsafe { decode::<EmptyStruct>(&mut bytes) } {
             assert!(result == &record);
             assert!(rest.len() == 0);
@@ -68,6 +71,7 @@ mod tests {
         assert_eq!(bytes.len(), measure(&record));
 
         // decode from binary data
+        let mut bytes = AlignedBytes::<TupleStruct>::new(&mut bytes);
         if let Some((result, rest)) = unsafe { decode::<TupleStruct>(&mut bytes) } {
             assert!(result == &record);
             assert!(rest.len() == 0);
@@ -89,6 +93,7 @@ mod tests {
         assert_eq!(bytes.len(), measure(&record));
 
         // decode from binary data
+        let mut bytes = AlignedBytes::<GenericStruct<String, Vec<u8>>>::new(&mut bytes);
         if let Some((result, rest)) = unsafe { decode::<GenericStruct<String, Vec<u8>>>(&mut bytes) } {
             assert!(result == &record);
             assert!(rest.len() == 0);
@@ -115,6 +120,7 @@ mod tests {
         assert_eq!(bytes.len(), measure(&record));
 
         // decode from binary data
+        let mut bytes = AlignedBytes::<BasicEnum>::new(&mut bytes);
         if let Some((result, rest)) = unsafe { decode::<BasicEnum>(&mut bytes) } {
             assert!(result == &record);
             assert!(rest.len() == 0);
@@ -126,7 +132,7 @@ mod tests {
     pub enum DataEnum {
         A(String, u64, Vec<u8>),
         B,
-        C(String, String, String)
+        C(String, String, u16)
     }
 
     #[test]
@@ -141,6 +147,7 @@ mod tests {
         assert_eq!(bytes.len(), measure(&record));
 
         // decode from binary data
+        let mut bytes = AlignedBytes::<DataEnum>::new(&mut bytes);
         if let Some((result, rest)) = unsafe { decode::<DataEnum>(&mut bytes) } {
             assert!(result == &record);
             assert!(rest.len() == 0);
@@ -197,9 +204,32 @@ mod tests {
         assert_eq!(bytes.len(), measure(&record));
 
         // decode from binary data
+        let mut bytes = AlignedBytes::<StructUsingCratePath>::new(&mut bytes);
         if let Some((result, rest)) = unsafe { decode::<StructUsingCratePath>(&mut bytes) } {
             assert!(result == &record);
             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));
+
+        let mut bytes = AlignedBytes::<StructWithRef>::new(&mut bytes);
+        if let Some((result, rest)) = unsafe { decode::<StructWithRef>(&mut bytes) } {
+            assert!(result == &record);
+            assert!(rest.len() == 0);
+        }
+    }
 }