Zero Sized Types should not enable DoS about borsh-rs HOT 2 CLOSED

pub mod zst {
    /// A marker trait indicating that a zero-sized type can have its deserialization optimized away
    pub unsafe trait CanSkipDeserialize: Sized + crate::BorshDeserialize {}

    /// A wrapper around Vec<T> for ZSTs that invokes T::deserialize only
    /// once regardless of the length of the vector.
    #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct SkippableVec<T>(pub Vec<T>);

    impl<T: CanSkipDeserialize> From<SkippableVec<T>> for Vec<T> {
        fn from(value: SkippableVec<T>) -> Self {
            value.0
        }
    }

    /// A marker trait indicating that a type is zero-sized. Panics at compile time
    /// if implemented for a non-ZST.
    trait IsZst: Sized {
        const IS_ZST: () = assert!(core::mem::size_of::<Self>() == 0);
    }

    /// Prevent people from implementing CanSkipDeserialize for non-ZSTs by blanket
    /// implementing the IsZst marker trait.
    impl<T: CanSkipDeserialize> IsZst for T {}
}

impl<T: BorshDeserialize> BorshDeserialize for SkippableVec<T> {
    fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self> {
        let len = u32::deserialize_reader(reader)?;
        let mut result = vec![T::deserialize_reader(reader)?];
        let p = result.as_mut_ptr();
        unsafe {
            forget(result);
            let len = len.try_into().map_err(|_| ErrorKind::InvalidInput)?;
            let result = Vec::from_raw_parts(p, len, len);
            Ok(Self(result))
        }
    }
}

impl<T> BorshDeserialize for Vec<T>
where
    T: BorshDeserialize,
{
    #[inline]
    fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self> {
        let len = u32::deserialize_reader(reader)?;
        if len == 0 {
            Ok(Vec::new())
        } else if let Some(vec_bytes) = T::vec_from_reader(len, reader)? {
            Ok(vec_bytes)
        } else {
            // TODO(16): return capacity allocation when we can safely do that.
            let mut result = Vec::with_capacity(hint::cautious::<T>(len));
            for _ in 0..len {
                result.push(T::deserialize_reader(reader)?);
            }
            Ok(result)
        }
    }
}