Fixed tuples, added error for iterator length mismatch

Author: vigna

CHANGELOG.md

@@ -4,14 +4,18 @@
 
 ### New
 
-* The file format has unfortunately changed. The ReprHash (now AlignHash) of
-  arrays  was wrong and could have led to data corruption. We took this chance
-  to fix a number of AlignHash implementations.
+* The ReprHash (now AlignHash) of arrays was wrong and could have led to data
+  corruption. As a result, some serialized file might return an alignment
+  error.
 
 * The implementation for tuples was broken because it assumed that the memory
   layout would have been the same of the source layout. We now just support
-  tuples of zero-copy identical types up to size 12. For the other cases, it is
-  necessary to create a `repr(C)` tuple newtype.
+  tuples of zero-copy identical types up to size 12, and `TypeHash` for generic
+  tuples up to size 12 to help with the idiom `PhantomData<(T, U)>`. For the
+  other cases, it is necessary to create a `repr(C)` tuple newtype. Note that up
+  to ε-serde 0.7.0 we provided an erroneous implementation for mixed zero-copy
+  types. If you serialized a structure using such a tuple, it will be no longer
+  deserializable.
 
 ## [0.7.0] - 2025-02-18
 

epserde/src/deser/mod.rs

@@ -385,8 +385,9 @@ The serialized type is '{expected_type_name}' and the deserialized type is '{got
         got: u64,
     },
     #[error(
-r#"Wrong type repr hash. Expected: 0x{expected:016x} Actual: 0x{got:016x}.
+r#"Wrong alignment hash. Expected: 0x{expected:016x} Actual: 0x{got:016x}.
 You might be trying to deserialize a file that was serialized on an architecture with different alignment requirements, or some of the fields of the type have changed their copy type (zero or deep).
+You might also be trying to deserialize a tuple of mixed zero-copy types, which is no longer supported since 0.8.0, or to deserialize an array, whose alignment hash has been fixed in 0.8.0. 
 The serialized type is '{expected_type_name}' and the deserialized type is '{got_type_name}'."#
     )]
     /// The type representation hash is wrong. Probabliy the user is trying to

epserde/src/impls/iter.rs

@@ -102,7 +102,10 @@ impl<
         }
 
         if c != len {
-            Err(ser::Error::IteratorLengthMismatch { actual: c, expected: len })
+            Err(ser::Error::IteratorLengthMismatch {
+                actual: c,
+                expected: len,
+            })
         } else {
             Ok(())
         }
@@ -131,10 +134,12 @@ impl<
         }
 
         if c != len {
-            Err(ser::Error::IteratorLengthMismatch { actual: c, expected: len })
+            Err(ser::Error::IteratorLengthMismatch {
+                actual: c,
+                expected: len,
+            })
         } else {
             Ok(())
         }
     }
 }
-

epserde/src/impls/tuple.rs

@@ -14,24 +14,22 @@
 //!
 //! To circumvent this problem, you can define a tuple newtype with a `repr(C)`
 //! attribute.
-//! 
-//! Note that because of this limitation the standard technique of aggregating
-//! types in tuples to reduce the number of
-//! [`PhantomData`](core::marker::PhantomData) marker should be avoided, unless
-//! they are all [`ZeroCopy`].
+//!
+//! We also provide a [`TypeHash`] implementation for tuples of up to 12
+//! elements to help with the idiom `PhantomData<(T1, T2, …)>`.
+//!
+//! Note that up to ε-serde 0.7.0 we provided an erroneous implementation for
+//! mixed zero-copy types. If you serialized a structure using such a tuple,
+//! it will be no longer deserializable.
 
 use crate::prelude::*;
 use core::hash::Hash;
 use deser::*;
 use ser::*;
 
-macro_rules! impl_tuples {
+macro_rules! impl_type_hash {
     ($($t:ident),*) => {
-        impl<T: ZeroCopy> CopyType for ($($t,)*)  {
-            type Copy = Zero;
-		}
-
-		impl<T: TypeHash> TypeHash for ($($t,)*)
+		impl<$($t: TypeHash,)*> TypeHash for ($($t,)*)
         {
             #[inline(always)]
             fn type_hash(
@@ -43,6 +41,14 @@ macro_rules! impl_tuples {
                 )*
             }
         }
+    }
+}
+
+macro_rules! impl_tuples {
+    ($($t:ident),*) => {
+        impl<T: ZeroCopy> CopyType for ($($t,)*)  {
+            type Copy = Zero;
+		}
 
 		impl<T: AlignHash> AlignHash for ($($t,)*)
         {
@@ -107,3 +113,16 @@ macro_rules! impl_tuples_muncher {
 }
 
 impl_tuples_muncher!(T, T, T, T, T, T, T, T, T, T, T, T);
+
+macro_rules! impl_type_hash_muncher {
+    ($ty:ident, $($t:ident),*) => {
+        impl_type_hash!($ty, $($t),*);
+        impl_type_hash_muncher!($($t),*);
+    };
+    ($ty:ident) => {
+        impl_type_hash!($ty);
+    };
+    () => {};
+}
+
+impl_type_hash_muncher!(T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11);