postcard2 0.2.1

use serde_core::de::{self, DeserializeSeed, IntoDeserializer, Visitor};

use crate::de::flavors::{Flavor, Slice};
use crate::varint::{max_of_last_byte, varint_max};
use core::marker::PhantomData;

/// The deserialization error type
#[derive(Debug, PartialEq, Eq)]
#[non_exhaustive]
pub enum DeserializerError<PopErr, FinErr> {
    /// A Flavor-specific error occurred while extracting data
    PopError(PopErr),
    /// A Flavor-specific error occurred while finalizing the deserialization
    FinalizeError(FinErr),
    /// A bad boolean value, e.g. NOT `0` or `1` was encountered while deserializing
    BadBool,
    /// A bad varint value was encountered while deserializing
    BadVarint,
    /// A bad [`char`] value was encounterered while deserializing
    BadChar,
    /// A bad UTF-8 string was encountered while deserializing
    BadUtf8,
    /// A bad [`Option`] was encountered while deserializing, e.g. the descriminant
    /// value was NEITHER `0` (for `None`) nor `1` (for `Some`)
    BadOption,
    /// The deserializer was requested to perform the `deserialize_any` action
    /// that postcard does not and will not ever support
    UnsupportedDeserAny,
    /// The deserializer was requested to perform the `deserialize_identifier` action
    /// that postcard does not and will not ever support
    UnsupportedDeserIdent,
    /// The deserializer was requested to perform the `deserialize_ignored_any` action
    /// that postcard does not and will not ever support
    UnsupportedDeserIgnoredAny,
    /// Serde returned a Custom error
    ///
    /// With the `alloc` or `std` features enabled, this will contain a formatted string.
    /// Without these features, the error context is not retained
    Custom(SerdeCustomError),
}

#[cfg(not(any(feature = "std", feature = "alloc")))]
mod custom {
    #[derive(Debug, PartialEq, Eq)]
    pub struct SerdeCustomError {
        inner: (),
    }

    impl core::fmt::Display for SerdeCustomError {
        #[inline]
        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
            f.write_str("SerdeCustomError(...)")
        }
    }

    impl<PopErr, FinErr> serde_core::de::Error for super::DeserializerError<PopErr, FinErr>
    where
        PopErr: core::fmt::Debug + core::fmt::Display,
        FinErr: core::fmt::Debug + core::fmt::Display,
    {
        #[inline]
        fn custom<T>(_msg: T) -> Self
        where
            T: core::fmt::Display,
        {
            super::DeserializerError::Custom(SerdeCustomError { inner: () })
        }
    }
}

#[cfg(any(feature = "std", feature = "alloc"))]
mod custom {
    extern crate alloc;

    #[derive(Debug, PartialEq, Eq)]
    pub struct SerdeCustomError {
        inner: alloc::string::String,
    }

    impl core::fmt::Display for SerdeCustomError {
        #[inline]
        fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
            write!(f, "SerdeCustomError({})", self.inner)
        }
    }

    impl<PopErr, FinErr> serde_core::de::Error for super::DeserializerError<PopErr, FinErr>
    where
        PopErr: core::fmt::Debug + core::fmt::Display,
        FinErr: core::fmt::Debug + core::fmt::Display,
    {
        #[inline]
        fn custom<T>(msg: T) -> Self
        where
            T: core::fmt::Display,
        {
            use alloc::string::ToString;
            super::DeserializerError::Custom(SerdeCustomError {
                inner: msg.to_string(),
            })
        }
    }
}

pub use custom::SerdeCustomError;

impl<PopErr, FinErr> core::fmt::Display for DeserializerError<PopErr, FinErr>
where
    PopErr: core::fmt::Display,
    FinErr: core::fmt::Display,
{
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        match self {
            DeserializerError::PopError(e) => write!(f, "PopError({e})"),
            DeserializerError::FinalizeError(e) => write!(f, "FinalizeError({e})"),
            DeserializerError::BadBool => f.write_str("BadBool"),
            DeserializerError::BadVarint => f.write_str("BadVarint"),
            DeserializerError::BadChar => f.write_str("BadChar"),
            DeserializerError::BadUtf8 => f.write_str("BadUtf8"),
            DeserializerError::BadOption => f.write_str("BadOption"),
            DeserializerError::UnsupportedDeserAny => f.write_str("UnsupportedDeserAny"),
            DeserializerError::UnsupportedDeserIdent => f.write_str("UnsupportedDeserIdent"),
            DeserializerError::UnsupportedDeserIgnoredAny => {
                f.write_str("UnsupportedDeserIgnoredAny")
            }
            DeserializerError::Custom(serde_custom_error) => serde_custom_error.fmt(f),
        }
    }
}

impl<PopErr, FinErr> core::error::Error for DeserializerError<PopErr, FinErr>
where
    PopErr: core::fmt::Debug + core::fmt::Display,
    FinErr: core::fmt::Debug + core::fmt::Display,
{
}

/// A `serde` compatible deserializer, generic over “Flavors” of deserializing plugins.
///
/// Please note that postcard messages are not self-describing and therefore incompatible with
/// [internally tagged enums](https://serde.rs/enum-representations.html#internally-tagged).
pub struct Deserializer<'de, F: Flavor<'de>> {
    flavor: F,
    _plt: PhantomData<&'de ()>,
}

impl<'de, F> Deserializer<'de, F>
where
    F: Flavor<'de> + 'de,
{
    /// Obtain a Deserializer from a slice of bytes
    pub fn from_flavor(flavor: F) -> Self {
        Deserializer {
            flavor,
            _plt: PhantomData,
        }
    }

    /// Return the remaining (unused) bytes in the Deserializer along with any
    /// additional data provided by the [`Flavor`]
    pub fn finalize(
        self,
    ) -> Result<F::Remainder, DeserializerError<F::PopError, F::FinalizeError>> {
        self.flavor
            .finalize()
            .map_err(DeserializerError::FinalizeError)
    }
}

impl<'de> Deserializer<'de, Slice<'de>> {
    /// Obtain a Deserializer from a slice of bytes
    pub fn from_bytes(input: &'de [u8]) -> Self {
        Deserializer {
            flavor: Slice::new(input),
            _plt: PhantomData,
        }
    }
}

impl<'de, F: Flavor<'de>> Deserializer<'de, F> {
    #[cfg(target_pointer_width = "16")]
    #[inline(always)]
    fn try_take_varint_usize(
        &mut self,
    ) -> Result<usize, DeserializerError<F::PopError, F::FinalizeError>> {
        self.try_take_varint_u16().map(|u| u as usize)
    }

    #[cfg(target_pointer_width = "32")]
    #[inline(always)]
    fn try_take_varint_usize(
        &mut self,
    ) -> Result<usize, DeserializerError<F::PopError, F::FinalizeError>> {
        self.try_take_varint_u32().map(|u| u as usize)
    }

    #[cfg(target_pointer_width = "64")]
    #[inline(always)]
    fn try_take_varint_usize(
        &mut self,
    ) -> Result<usize, DeserializerError<F::PopError, F::FinalizeError>> {
        self.try_take_varint_u64().map(|u| u as usize)
    }

    #[inline]
    fn try_take_varint_u16(
        &mut self,
    ) -> Result<u16, DeserializerError<F::PopError, F::FinalizeError>> {
        let mut out = 0;
        for i in 0..varint_max::<u16>() {
            let val = self.flavor.pop().map_err(DeserializerError::PopError)?;
            let carry = (val & 0x7F) as u16;
            out |= carry << (7 * i);

            if (val & 0x80) == 0 {
                if i == varint_max::<u16>() - 1 && val > max_of_last_byte::<u16>() {
                    return Err(DeserializerError::BadVarint);
                } else {
                    return Ok(out);
                }
            }
        }
        Err(DeserializerError::BadVarint)
    }

    #[inline]
    fn try_take_varint_u32(
        &mut self,
    ) -> Result<u32, DeserializerError<F::PopError, F::FinalizeError>> {
        let mut out = 0;
        for i in 0..varint_max::<u32>() {
            let val = self.flavor.pop().map_err(DeserializerError::PopError)?;
            let carry = (val & 0x7F) as u32;
            out |= carry << (7 * i);

            if (val & 0x80) == 0 {
                if i == varint_max::<u32>() - 1 && val > max_of_last_byte::<u32>() {
                    return Err(DeserializerError::BadVarint);
                } else {
                    return Ok(out);
                }
            }
        }
        Err(DeserializerError::BadVarint)
    }

    #[inline]
    fn try_take_varint_u64(
        &mut self,
    ) -> Result<u64, DeserializerError<F::PopError, F::FinalizeError>> {
        let mut out = 0;
        for i in 0..varint_max::<u64>() {
            let val = self.flavor.pop().map_err(DeserializerError::PopError)?;
            let carry = (val & 0x7F) as u64;
            out |= carry << (7 * i);

            if (val & 0x80) == 0 {
                if i == varint_max::<u64>() - 1 && val > max_of_last_byte::<u64>() {
                    return Err(DeserializerError::BadVarint);
                } else {
                    return Ok(out);
                }
            }
        }
        Err(DeserializerError::BadVarint)
    }

    #[inline]
    fn try_take_varint_u128(
        &mut self,
    ) -> Result<u128, DeserializerError<F::PopError, F::FinalizeError>> {
        let mut out = 0;
        for i in 0..varint_max::<u128>() {
            let val = self.flavor.pop().map_err(DeserializerError::PopError)?;
            let carry = (val & 0x7F) as u128;
            out |= carry << (7 * i);

            if (val & 0x80) == 0 {
                if i == varint_max::<u128>() - 1 && val > max_of_last_byte::<u128>() {
                    return Err(DeserializerError::BadVarint);
                } else {
                    return Ok(out);
                }
            }
        }
        Err(DeserializerError::BadVarint)
    }
}

struct SeqAccess<'a, 'b, F: Flavor<'b>> {
    deserializer: &'a mut Deserializer<'b, F>,
    len: usize,
}

impl<'a, 'b: 'a, F: Flavor<'b>> serde_core::de::SeqAccess<'b> for SeqAccess<'a, 'b, F> {
    type Error = DeserializerError<F::PopError, F::FinalizeError>;

    #[inline]
    fn next_element_seed<V: DeserializeSeed<'b>>(
        &mut self,
        seed: V,
    ) -> Result<Option<V::Value>, DeserializerError<F::PopError, F::FinalizeError>> {
        if self.len > 0 {
            self.len -= 1;
            Ok(Some(DeserializeSeed::deserialize(
                seed,
                &mut *self.deserializer,
            )?))
        } else {
            Ok(None)
        }
    }

    #[inline]
    fn size_hint(&self) -> Option<usize> {
        match self.deserializer.flavor.size_hint() {
            Some(size) if size < self.len => None,
            _ => Some(self.len),
        }
    }
}

struct MapAccess<'a, 'b, F: Flavor<'b>> {
    deserializer: &'a mut Deserializer<'b, F>,
    len: usize,
}

impl<'a, 'b: 'a, F: Flavor<'b>> serde_core::de::MapAccess<'b> for MapAccess<'a, 'b, F> {
    type Error = DeserializerError<F::PopError, F::FinalizeError>;

    #[inline]
    fn next_key_seed<K: DeserializeSeed<'b>>(
        &mut self,
        seed: K,
    ) -> Result<Option<K::Value>, DeserializerError<F::PopError, F::FinalizeError>> {
        if self.len > 0 {
            self.len -= 1;
            Ok(Some(DeserializeSeed::deserialize(
                seed,
                &mut *self.deserializer,
            )?))
        } else {
            Ok(None)
        }
    }

    #[inline]
    fn next_value_seed<V: DeserializeSeed<'b>>(
        &mut self,
        seed: V,
    ) -> Result<V::Value, DeserializerError<F::PopError, F::FinalizeError>> {
        DeserializeSeed::deserialize(seed, &mut *self.deserializer)
    }

    #[inline]
    fn size_hint(&self) -> Option<usize> {
        Some(self.len)
    }
}

impl<'de, F: Flavor<'de>> de::Deserializer<'de> for &mut Deserializer<'de, F> {
    type Error = DeserializerError<F::PopError, F::FinalizeError>;

    #[inline]
    fn is_human_readable(&self) -> bool {
        false
    }

    // Postcard does not support structures not known at compile time
    #[inline]
    fn deserialize_any<V>(
        self,
        _visitor: V,
    ) -> Result<V::Value, DeserializerError<F::PopError, F::FinalizeError>>
    where
        V: Visitor<'de>,
    {
        // We wont ever support this.
        Err(DeserializerError::UnsupportedDeserAny)
    }

    // Take a boolean encoded as a u8
    #[inline]
    fn deserialize_bool<V>(
        self,
        visitor: V,
    ) -> Result<V::Value, DeserializerError<F::PopError, F::FinalizeError>>
    where
        V: Visitor<'de>,
    {
        let val = match self.flavor.pop() {
            Ok(0) => false,
            Ok(1) => true,
            Ok(_) => return Err(DeserializerError::BadBool),
            Err(e) => return Err(DeserializerError::PopError(e)),
        };
        visitor.visit_bool(val)
    }

    #[inline]
    fn deserialize_i8<V>(
        self,
        visitor: V,
    ) -> Result<V::Value, DeserializerError<F::PopError, F::FinalizeError>>
    where
        V: Visitor<'de>,
    {
        visitor.visit_i8(self.flavor.pop().map_err(DeserializerError::PopError)? as i8)
    }

    #[inline]
    fn deserialize_i16<V>(
        self,
        visitor: V,
    ) -> Result<V::Value, DeserializerError<F::PopError, F::FinalizeError>>
    where
        V: Visitor<'de>,
    {
        let v = self.try_take_varint_u16()?;
        visitor.visit_i16(de_zig_zag_i16(v))
    }

    #[inline]
    fn deserialize_i32<V>(
        self,
        visitor: V,
    ) -> Result<V::Value, DeserializerError<F::PopError, F::FinalizeError>>
    where
        V: Visitor<'de>,
    {
        let v = self.try_take_varint_u32()?;
        visitor.visit_i32(de_zig_zag_i32(v))
    }

    #[inline]
    fn deserialize_i64<V>(
        self,
        visitor: V,
    ) -> Result<V::Value, DeserializerError<F::PopError, F::FinalizeError>>
    where
        V: Visitor<'de>,
    {
        let v = self.try_take_varint_u64()?;
        visitor.visit_i64(de_zig_zag_i64(v))
    }

    #[inline]
    fn deserialize_i128<V>(
        self,
        visitor: V,
    ) -> Result<V::Value, DeserializerError<F::PopError, F::FinalizeError>>
    where
        V: Visitor<'de>,
    {
        let v = self.try_take_varint_u128()?;
        visitor.visit_i128(de_zig_zag_i128(v))
    }

    #[inline]
    fn deserialize_u8<V>(
        self,
        visitor: V,
    ) -> Result<V::Value, DeserializerError<F::PopError, F::FinalizeError>>
    where
        V: Visitor<'de>,
    {
        visitor.visit_u8(self.flavor.pop().map_err(DeserializerError::PopError)?)
    }

    #[inline]
    fn deserialize_u16<V>(
        self,
        visitor: V,
    ) -> Result<V::Value, DeserializerError<F::PopError, F::FinalizeError>>
    where
        V: Visitor<'de>,
    {
        let v = self.try_take_varint_u16()?;
        visitor.visit_u16(v)
    }

    #[inline]
    fn deserialize_u32<V>(
        self,
        visitor: V,
    ) -> Result<V::Value, DeserializerError<F::PopError, F::FinalizeError>>
    where
        V: Visitor<'de>,
    {
        let v = self.try_take_varint_u32()?;
        visitor.visit_u32(v)
    }

    #[inline]
    fn deserialize_u64<V>(
        self,
        visitor: V,
    ) -> Result<V::Value, DeserializerError<F::PopError, F::FinalizeError>>
    where
        V: Visitor<'de>,
    {
        let v = self.try_take_varint_u64()?;
        visitor.visit_u64(v)
    }

    #[inline]
    fn deserialize_u128<V>(
        self,
        visitor: V,
    ) -> Result<V::Value, DeserializerError<F::PopError, F::FinalizeError>>
    where
        V: Visitor<'de>,
    {
        let v = self.try_take_varint_u128()?;
        visitor.visit_u128(v)
    }

    #[inline]
    fn deserialize_f32<V>(
        self,
        visitor: V,
    ) -> Result<V::Value, DeserializerError<F::PopError, F::FinalizeError>>
    where
        V: Visitor<'de>,
    {
        let bytes = self
            .flavor
            .try_take_n_temp(4)
            .map_err(DeserializerError::PopError)?;
        let mut buf = [0u8; 4];
        buf.copy_from_slice(bytes);
        visitor.visit_f32(f32::from_bits(u32::from_le_bytes(buf)))
    }

    #[inline]
    fn deserialize_f64<V>(
        self,
        visitor: V,
    ) -> Result<V::Value, DeserializerError<F::PopError, F::FinalizeError>>
    where
        V: Visitor<'de>,
    {
        let bytes = self
            .flavor
            .try_take_n_temp(8)
            .map_err(DeserializerError::PopError)?;
        let mut buf = [0u8; 8];
        buf.copy_from_slice(bytes);
        visitor.visit_f64(f64::from_bits(u64::from_le_bytes(buf)))
    }

    #[inline]
    fn deserialize_char<V>(
        self,
        visitor: V,
    ) -> Result<V::Value, DeserializerError<F::PopError, F::FinalizeError>>
    where
        V: Visitor<'de>,
    {
        let sz = self.try_take_varint_usize()?;
        if sz > 4 {
            return Err(DeserializerError::BadChar);
        }
        let bytes: &[u8] = self
            .flavor
            .try_take_n_temp(sz)
            .map_err(DeserializerError::PopError)?;
        // we pass the character through string conversion because
        // this handles transforming the array of code units to a
        // codepoint. we can't use char::from_u32() because it expects
        // an already-processed codepoint.
        let character = core::str::from_utf8(bytes)
            .map_err(|_| DeserializerError::BadChar)?
            .chars()
            .next()
            .ok_or(DeserializerError::BadChar)?;
        visitor.visit_char(character)
    }

    #[inline]
    fn deserialize_str<V>(
        self,
        visitor: V,
    ) -> Result<V::Value, DeserializerError<F::PopError, F::FinalizeError>>
    where
        V: Visitor<'de>,
    {
        let sz = self.try_take_varint_usize()?;
        let bytes: &'de [u8] = self
            .flavor
            .try_take_n(sz)
            .map_err(DeserializerError::PopError)?;
        let str_sl = core::str::from_utf8(bytes).map_err(|_| DeserializerError::BadUtf8)?;

        visitor.visit_borrowed_str(str_sl)
    }

    #[inline]
    fn deserialize_string<V>(
        self,
        visitor: V,
    ) -> Result<V::Value, DeserializerError<F::PopError, F::FinalizeError>>
    where
        V: Visitor<'de>,
    {
        let sz = self.try_take_varint_usize()?;
        let bytes: &[u8] = self
            .flavor
            .try_take_n_temp(sz)
            .map_err(DeserializerError::PopError)?;
        let str_sl = core::str::from_utf8(bytes).map_err(|_| DeserializerError::BadUtf8)?;

        visitor.visit_str(str_sl)
    }

    #[inline]
    fn deserialize_bytes<V>(
        self,
        visitor: V,
    ) -> Result<V::Value, DeserializerError<F::PopError, F::FinalizeError>>
    where
        V: Visitor<'de>,
    {
        let sz = self.try_take_varint_usize()?;
        let bytes: &'de [u8] = self
            .flavor
            .try_take_n(sz)
            .map_err(DeserializerError::PopError)?;
        visitor.visit_borrowed_bytes(bytes)
    }

    #[inline]
    fn deserialize_byte_buf<V>(
        self,
        visitor: V,
    ) -> Result<V::Value, DeserializerError<F::PopError, F::FinalizeError>>
    where
        V: Visitor<'de>,
    {
        let sz = self.try_take_varint_usize()?;
        let bytes: &[u8] = self
            .flavor
            .try_take_n_temp(sz)
            .map_err(DeserializerError::PopError)?;
        visitor.visit_bytes(bytes)
    }

    #[inline]
    fn deserialize_option<V>(
        self,
        visitor: V,
    ) -> Result<V::Value, DeserializerError<F::PopError, F::FinalizeError>>
    where
        V: Visitor<'de>,
    {
        match self.flavor.pop() {
            Ok(0) => visitor.visit_none(),
            Ok(1) => visitor.visit_some(self),
            Ok(_) => Err(DeserializerError::BadOption),
            Err(e) => Err(DeserializerError::PopError(e)),
        }
    }

    // In Serde, unit means an anonymous value containing no data.
    // Unit is not actually encoded in Postcard.
    #[inline]
    fn deserialize_unit<V>(
        self,
        visitor: V,
    ) -> Result<V::Value, DeserializerError<F::PopError, F::FinalizeError>>
    where
        V: Visitor<'de>,
    {
        visitor.visit_unit()
    }

    // Unit struct means a named value containing no data.
    // Unit structs are not actually encoded in Postcard.
    #[inline]
    fn deserialize_unit_struct<V>(
        self,
        _name: &'static str,
        visitor: V,
    ) -> Result<V::Value, DeserializerError<F::PopError, F::FinalizeError>>
    where
        V: Visitor<'de>,
    {
        self.deserialize_unit(visitor)
    }

    #[inline]
    fn deserialize_newtype_struct<V>(
        self,
        _name: &'static str,
        visitor: V,
    ) -> Result<V::Value, DeserializerError<F::PopError, F::FinalizeError>>
    where
        V: Visitor<'de>,
    {
        visitor.visit_newtype_struct(self)
    }

    #[inline]
    fn deserialize_seq<V>(
        self,
        visitor: V,
    ) -> Result<V::Value, DeserializerError<F::PopError, F::FinalizeError>>
    where
        V: Visitor<'de>,
    {
        let len = self.try_take_varint_usize()?;

        visitor.visit_seq(SeqAccess {
            deserializer: self,
            len,
        })
    }

    #[inline]
    fn deserialize_tuple<V>(
        self,
        len: usize,
        visitor: V,
    ) -> Result<V::Value, DeserializerError<F::PopError, F::FinalizeError>>
    where
        V: Visitor<'de>,
    {
        visitor.visit_seq(SeqAccess {
            deserializer: self,
            len,
        })
    }

    #[inline]
    fn deserialize_tuple_struct<V>(
        self,
        _name: &'static str,
        len: usize,
        visitor: V,
    ) -> Result<V::Value, DeserializerError<F::PopError, F::FinalizeError>>
    where
        V: Visitor<'de>,
    {
        self.deserialize_tuple(len, visitor)
    }

    #[inline]
    fn deserialize_map<V>(
        self,
        visitor: V,
    ) -> Result<V::Value, DeserializerError<F::PopError, F::FinalizeError>>
    where
        V: Visitor<'de>,
    {
        let len = self.try_take_varint_usize()?;

        visitor.visit_map(MapAccess {
            deserializer: self,
            len,
        })
    }

    #[inline]
    fn deserialize_struct<V>(
        self,
        _name: &'static str,
        fields: &'static [&'static str],
        visitor: V,
    ) -> Result<V::Value, DeserializerError<F::PopError, F::FinalizeError>>
    where
        V: Visitor<'de>,
    {
        self.deserialize_tuple(fields.len(), visitor)
    }

    #[inline]
    fn deserialize_enum<V>(
        self,
        _name: &'static str,
        _variants: &'static [&'static str],
        visitor: V,
    ) -> Result<V::Value, DeserializerError<F::PopError, F::FinalizeError>>
    where
        V: Visitor<'de>,
    {
        visitor.visit_enum(self)
    }

    // As a binary format, Postcard does not encode identifiers
    #[inline]
    fn deserialize_identifier<V>(
        self,
        _visitor: V,
    ) -> Result<V::Value, DeserializerError<F::PopError, F::FinalizeError>>
    where
        V: Visitor<'de>,
    {
        // Will not support
        Err(DeserializerError::UnsupportedDeserIdent)
    }

    #[inline]
    fn deserialize_ignored_any<V>(
        self,
        _visitor: V,
    ) -> Result<V::Value, DeserializerError<F::PopError, F::FinalizeError>>
    where
        V: Visitor<'de>,
    {
        // Will not support
        Err(DeserializerError::UnsupportedDeserIgnoredAny)
    }
}

impl<'de, F: Flavor<'de>> serde_core::de::VariantAccess<'de> for &mut Deserializer<'de, F> {
    type Error = DeserializerError<F::PopError, F::FinalizeError>;

    #[inline]
    fn unit_variant(self) -> Result<(), DeserializerError<F::PopError, F::FinalizeError>> {
        Ok(())
    }

    #[inline]
    fn newtype_variant_seed<V: DeserializeSeed<'de>>(
        self,
        seed: V,
    ) -> Result<V::Value, DeserializerError<F::PopError, F::FinalizeError>> {
        DeserializeSeed::deserialize(seed, self)
    }

    #[inline]
    fn tuple_variant<V: Visitor<'de>>(
        self,
        len: usize,
        visitor: V,
    ) -> Result<V::Value, DeserializerError<F::PopError, F::FinalizeError>> {
        serde_core::de::Deserializer::deserialize_tuple(self, len, visitor)
    }

    #[inline]
    fn struct_variant<V: Visitor<'de>>(
        self,
        fields: &'static [&'static str],
        visitor: V,
    ) -> Result<V::Value, DeserializerError<F::PopError, F::FinalizeError>> {
        serde_core::de::Deserializer::deserialize_tuple(self, fields.len(), visitor)
    }
}

impl<'de, F: Flavor<'de>> serde_core::de::EnumAccess<'de> for &mut Deserializer<'de, F> {
    type Error = DeserializerError<F::PopError, F::FinalizeError>;
    type Variant = Self;

    #[inline]
    fn variant_seed<V: DeserializeSeed<'de>>(
        self,
        seed: V,
    ) -> Result<(V::Value, Self), DeserializerError<F::PopError, F::FinalizeError>> {
        let varint = self.try_take_varint_u32()?;
        let v = DeserializeSeed::deserialize(seed, varint.into_deserializer())?;
        Ok((v, self))
    }
}

fn de_zig_zag_i16(n: u16) -> i16 {
    ((n >> 1) as i16) ^ (-((n & 0b1) as i16))
}

fn de_zig_zag_i32(n: u32) -> i32 {
    ((n >> 1) as i32) ^ (-((n & 0b1) as i32))
}

fn de_zig_zag_i64(n: u64) -> i64 {
    ((n >> 1) as i64) ^ (-((n & 0b1) as i64))
}

fn de_zig_zag_i128(n: u128) -> i128 {
    ((n >> 1) as i128) ^ (-((n & 0b1) as i128))
}