Use/require byte equality in VarZeroVec

utils/zerovec/src/ule/mod.rs

@@ -19,7 +19,20 @@ pub use plain::PlainOldULE;
 ///
 /// # Safety
 ///
-/// See the safety invariant documented on [`Self::from_byte_slice_unchecked()`] to implement this trait.
+/// There must be no padding bytes involved in this type: [`Self::as_byte_slice()`] MUST return
+/// a slice of initialized bytes provided that `Self` is initialized.
+///
+/// This method _must_ be implemented to return the same result as [`ULE::parse_byte_slice()`].
+///
+/// [`ULE::as_byte_slice()`] should return a slice that is the in-memory representation of `Self`,
+/// i.e. it should be just a pointer cast, and `mem::size_of_val(self) == mem::size_of_val(self.as_byte_slice())`=
+///
+/// # Equality invariant
+///
+/// A non-safety invariant is that if `Self` implements `PartialEq`, it *must* be logically equivalent to
+/// byte equality on `.as_byte_slice()`. Failure to follow this invariant will not cause undefined
+/// behavior, but may cause problems in the `PartialEq` implementations of `ZeroVec` and `VarZeroVec`,
+/// as well as the predictable operation of `ZeroMap`
 pub unsafe trait ULE
 where
     Self: Sized,
@@ -66,9 +79,9 @@ where
     ///
     /// # Safety
     ///
-    /// In most cases, the implementation of this function should involve re-casting the pointer.
+    /// The implementation of this function should involve re-casting the pointer.
     /// It is up to the implementation to reason about the safety. Keep in mind that `&[Self]` and
-    /// `&[u8]` may have different lengths.
+    /// `&[u8]` may have different lengths (but should cover the same data).
     #[allow(clippy::wrong_self_convention)] // https://github.com/rust-lang/rust-clippy/issues/7219
     fn as_byte_slice(slice: &[Self]) -> &[u8];
 }
@@ -194,6 +207,16 @@ pub trait AsVarULE {
 ///
 /// [`VarULE::from_byte_slice_unchecked()`] _must_ be implemented to return the same result
 /// as [`VarULE::parse_byte_slice()`] provided both are passed the same validly parsing byte slices.
+///
+/// [`VarULE::as_byte_slice()`] should return a slice that is the in-memory representation of `Self`,
+/// i.e. it should be just a pointer cast, and `mem::size_of_val(self) == mem::size_of_val(self.as_byte_slice())`
+///
+/// # Equality invariant
+///
+/// A non-safety invariant is that if `Self` implements `PartialEq`, it *must* be logically equivalent to
+/// byte equality on `.as_byte_slice()`. Failure to follow this invariant will not cause undefined
+/// behavior, but may cause problems in the `PartialEq` implementations of `ZeroVec` and `VarZeroVec`,
+/// as well as the predictable operation of `ZeroMap`.
 pub unsafe trait VarULE: 'static {
     /// The error type to used by [`VarULE::parse_byte_slice()`]
     type Error;
@@ -233,7 +256,7 @@ pub unsafe trait VarULE: 'static {
     ///
     /// # Safety
     ///
-    /// In most cases, the implementation of this function should involve re-casting the pointer.
+    /// The implementation of this function should involve re-casting the pointer.
     /// It is up to the implementation to reason about the safety.
     fn as_byte_slice(&self) -> &[u8];
 }

utils/zerovec/src/varzerovec/components.rs

@@ -294,12 +294,10 @@ pub fn get_serializable_bytes<T: AsVarULE>(elements: &[T]) -> Option<Vec<u8>> {
     let mut offset: u32 = 0;
     for element in elements {
         vec.extend(&offset.as_unaligned().0);
-        let len_u32: u32 = element
-            .as_unaligned()
-            .as_byte_slice()
-            .len()
-            .try_into()
-            .ok()?;
+        let ule = element.as_unaligned();
+        let slice = ule.as_byte_slice();
+        debug_assert_eq!(mem::size_of_val(ule), mem::size_of_val(slice));
+        let len_u32: u32 = slice.len().try_into().ok()?;
         offset = offset.checked_add(len_u32)?;
     }
     vec.reserve(offset as usize);

utils/zerovec/src/varzerovec/mod.rs

@@ -406,7 +406,10 @@ impl<'a, T: AsVarULE> VarZeroVec<'a, T> {
     ///
     /// This can be passed back to [`Self::parse_byte_slice()`]
     pub fn get_encoded_slice(&self) -> &[u8] {
-        self.get_components().entire_slice()
+        match self.0 {
+            VarZeroVecInner::Owned(ref vec) => vec.entire_slice(),
+            VarZeroVecInner::Borrowed(vec) => vec.entire_slice(),
+        }
     }
 
     /// For a slice of `T`, get a list of bytes that can be passed to
@@ -501,8 +504,9 @@ where
 {
     #[inline]
     fn eq(&self, other: &VarZeroVec<'b, T>) -> bool {
-        // Note: T implements PartialEq but not T::ULE
-        self.iter().eq(other.iter())
+        // VarULE has an API guarantee that this is equivalent
+        // to `T::VarULE::eq()`
+        self.get_encoded_slice().eq(other.get_encoded_slice())
     }
 }
 

utils/zerovec/src/varzerovec/owned.rs

@@ -110,6 +110,11 @@ impl<T: AsVarULE> VarZeroVecOwned<T> {
         self.get_components().to_vec()
     }
 
+    #[inline]
+    pub fn entire_slice(&self) -> &[u8] {
+        &self.entire_slice
+    }
+
     /// Insert an element at index `idx`
     pub fn insert(&mut self, index: usize, element: &T) {
         let len = self.len();

utils/zerovec/src/varzerovec/ule.rs

@@ -147,8 +147,9 @@ where
 {
     #[inline]
     fn eq(&self, other: &VarZeroVecULE<T>) -> bool {
-        // Note: T implements PartialEq but not T::ULE
-        self.iter().eq(other.iter())
+        // VarULE has an API guarantee that this is equivalent
+        // to `T::VarULE::eq()`
+        self.entire_slice.eq(&other.entire_slice)
     }
 }