serde_buf 0.1.3

use core::{fmt, mem};

use alloc::{string::ToString, vec::Vec};
use core::fmt::Display;
use serde_core::{
    ser::{
        self, SerializeMap as _, SerializeSeq as _, SerializeStruct as _,
        SerializeStructVariant as _, SerializeTuple as _, SerializeTupleStruct as _,
        SerializeTupleVariant as _,
    },
    Serialize,
};

use crate::{
    raw::{
        skip, Cursor, Frame, Leaf, MapHeader, PartBuf, PartVisitor, SeqHeader, StructHeader,
        StructVariantHeader, TupleHeader, TupleStructHeader, TupleVariantHeader, VariantHeader,
    },
    Error, Owned, Ref, RefValue,
};

impl ser::Error for Error {
    fn custom<T>(msg: T) -> Self
    where
        T: fmt::Display,
    {
        Error(msg.to_string())
    }
}

impl<'a> Serialize for Ref<'a> {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde_core::Serializer,
    {
        self.0.serialize(serializer)
    }
}

impl<'a> Serialize for RefValue<'a> {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde_core::Serializer,
    {
        match self {
            RefValue::Leaf(leaf) => leaf.serialize(serializer),
            RefValue::Value(value) => value.serialize(serializer),
        }
    }
}

impl<'a> Serialize for Leaf<'a> {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde_core::Serializer,
    {
        match *self {
            Leaf::Unit => serializer.serialize_unit(),
            Leaf::Bool(v) => serializer.serialize_bool(v),
            Leaf::U8(v) => serializer.serialize_u8(v),
            Leaf::U16(v) => serializer.serialize_u16(v),
            Leaf::U32(v) => serializer.serialize_u32(v),
            Leaf::U64(v) => serializer.serialize_u64(v),
            Leaf::U128(v) => serializer.serialize_u128(v),
            Leaf::I8(v) => serializer.serialize_i8(v),
            Leaf::I16(v) => serializer.serialize_i16(v),
            Leaf::I32(v) => serializer.serialize_i32(v),
            Leaf::I64(v) => serializer.serialize_i64(v),
            Leaf::I128(v) => serializer.serialize_i128(v),
            Leaf::F32(v) => serializer.serialize_f32(v),
            Leaf::F64(v) => serializer.serialize_f64(v),
            Leaf::Char(v) => serializer.serialize_char(v),
            Leaf::Str(v) => serializer.serialize_str(v),
            Leaf::Bytes(v) => serializer.serialize_bytes(v),
            Leaf::None => serializer.serialize_none(),
            Leaf::UnitStruct(name) => serializer.serialize_unit_struct(name),
            Leaf::UnitVariant {
                name,
                variant_index,
                variant,
            } => serializer.serialize_unit_variant(name, variant_index, variant),
        }
    }
}

impl Serialize for Owned {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde_core::Serializer,
    {
        self.0.serialize(serializer)
    }
}

impl<'a, T: AsRef<[u8]>> Serialize for PartBuf<'a, T> {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde_core::Serializer,
    {
        SerializePart {
            bytes: self.bytes(),
            pos: 0,
        }
        .serialize(serializer)
    }
}

struct SerializePart<'i> {
    bytes: &'i [u8],
    pos: usize,
}

impl<'i> Serialize for SerializePart<'i> {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde_core::Serializer,
    {
        struct SerializePartVisitor<S> {
            serializer: S,
        }

        impl<'i, 'de, S: serde_core::Serializer> PartVisitor<'i, 'de> for SerializePartVisitor<S> {
            type Output = Result<S::Ok, S::Error>;

            fn visit_unit(self) -> Self::Output {
                self.serializer.serialize_unit()
            }

            fn visit_bool(self, v: bool) -> Self::Output {
                self.serializer.serialize_bool(v)
            }

            fn visit_u8(self, v: u8) -> Self::Output {
                self.serializer.serialize_u8(v)
            }

            fn visit_u16(self, v: u16) -> Self::Output {
                self.serializer.serialize_u16(v)
            }

            fn visit_u32(self, v: u32) -> Self::Output {
                self.serializer.serialize_u32(v)
            }

            fn visit_u64(self, v: u64) -> Self::Output {
                self.serializer.serialize_u64(v)
            }

            fn visit_u128(self, v: u128) -> Self::Output {
                self.serializer.serialize_u128(v)
            }

            fn visit_i8(self, v: i8) -> Self::Output {
                self.serializer.serialize_i8(v)
            }

            fn visit_i16(self, v: i16) -> Self::Output {
                self.serializer.serialize_i16(v)
            }

            fn visit_i32(self, v: i32) -> Self::Output {
                self.serializer.serialize_i32(v)
            }

            fn visit_i64(self, v: i64) -> Self::Output {
                self.serializer.serialize_i64(v)
            }

            fn visit_i128(self, v: i128) -> Self::Output {
                self.serializer.serialize_i128(v)
            }

            fn visit_f32(self, v: f32) -> Self::Output {
                self.serializer.serialize_f32(v)
            }

            fn visit_f64(self, v: f64) -> Self::Output {
                self.serializer.serialize_f64(v)
            }

            fn visit_char(self, v: char) -> Self::Output {
                self.serializer.serialize_char(v)
            }

            fn visit_str(self, v: &'i str) -> Self::Output {
                self.serializer.serialize_str(v)
            }

            fn visit_borrowed_str(self, v: &'de str) -> Self::Output {
                self.serializer.serialize_str(v)
            }

            fn visit_bytes(self, v: &'i [u8]) -> Self::Output {
                self.serializer.serialize_bytes(v)
            }

            fn visit_borrowed_bytes(self, v: &'de [u8]) -> Self::Output {
                self.serializer.serialize_bytes(v)
            }

            fn visit_none(self) -> Self::Output {
                self.serializer.serialize_none()
            }

            fn visit_some(self, cursor: &mut Cursor<'i, 'de>) -> Self::Output {
                self.serializer.serialize_some(&SerializePart {
                    bytes: cursor.bytes(),
                    pos: cursor.pos(),
                })
            }

            fn visit_unit_struct(self, name: &'static str) -> Self::Output {
                self.serializer.serialize_unit_struct(name)
            }

            fn visit_newtype_struct(
                self,
                name: &'static str,
                cursor: &mut Cursor<'i, 'de>,
            ) -> Self::Output {
                self.serializer.serialize_newtype_struct(
                    name,
                    &SerializePart {
                        bytes: cursor.bytes(),
                        pos: cursor.pos(),
                    },
                )
            }

            fn visit_unit_variant(
                self,
                header: VariantHeader,
                _: &mut Cursor<'i, 'de>,
            ) -> Self::Output {
                self.serializer.serialize_unit_variant(
                    header.name,
                    header.variant_index,
                    header.variant,
                )
            }

            fn visit_newtype_variant(
                self,
                header: VariantHeader,
                cursor: &mut Cursor<'i, 'de>,
            ) -> Self::Output {
                self.serializer.serialize_newtype_variant(
                    header.name,
                    header.variant_index,
                    header.variant,
                    &SerializePart {
                        bytes: cursor.bytes(),
                        pos: cursor.pos(),
                    },
                )
            }

            fn visit_seq(self, header: SeqHeader, cursor: &mut Cursor<'i, 'de>) -> Self::Output {
                let bytes = cursor.bytes();

                let mut serializer = self.serializer.serialize_seq(Some(header.num))?;

                let mut pos = cursor.pos();
                for _ in 0..header.num {
                    serializer.serialize_element(&SerializePart { bytes, pos })?;
                    pos = skip(bytes, pos);
                }

                serializer.end()
            }

            fn visit_tuple(
                self,
                header: TupleHeader,
                cursor: &mut Cursor<'i, 'de>,
            ) -> Self::Output {
                let bytes = cursor.bytes();

                let mut serializer = self.serializer.serialize_tuple(header.num)?;

                let mut pos = cursor.pos();
                for _ in 0..header.num {
                    serializer.serialize_element(&SerializePart { bytes, pos })?;
                    pos = skip(bytes, pos);
                }

                serializer.end()
            }

            fn visit_map(self, header: MapHeader, cursor: &mut Cursor<'i, 'de>) -> Self::Output {
                let bytes = cursor.bytes();

                let mut serializer = self.serializer.serialize_map(Some(header.num))?;

                let mut pos = cursor.pos();
                for _ in 0..header.num {
                    let value = skip(bytes, pos);

                    serializer.serialize_entry(
                        &SerializePart { bytes, pos },
                        &SerializePart { bytes, pos: value },
                    )?;
                    pos = skip(bytes, value);
                }

                serializer.end()
            }

            fn visit_tuple_struct(
                self,
                header: TupleStructHeader,
                cursor: &mut Cursor<'i, 'de>,
            ) -> Self::Output {
                let bytes = cursor.bytes();

                let mut serializer = self
                    .serializer
                    .serialize_tuple_struct(header.name, header.num)?;

                let mut pos = cursor.pos();
                for _ in 0..header.num {
                    serializer.serialize_field(&SerializePart { bytes, pos })?;
                    pos = skip(bytes, pos);
                }

                serializer.end()
            }

            fn visit_struct(
                self,
                header: StructHeader,
                cursor: &mut Cursor<'i, 'de>,
            ) -> Self::Output {
                let bytes = cursor.bytes();

                let mut serializer = self.serializer.serialize_struct(header.name, header.num)?;

                let mut pos = cursor.pos();
                for _ in 0..header.num {
                    // SAFETY: `pos` is at a field key: the decoded struct header
                    // leaves the cursor at the first key, and each `skip` past a
                    // field's value lands on the next
                    let mut cursor = unsafe { Cursor::at(bytes, pos) };
                    let key = unsafe { cursor.read_field_key() };

                    serializer.serialize_field(
                        key,
                        &SerializePart {
                            bytes,
                            pos: cursor.pos(),
                        },
                    )?;
                    pos = skip(bytes, cursor.pos());
                }

                serializer.end()
            }

            fn visit_tuple_variant(
                self,
                header: TupleVariantHeader,
                cursor: &mut Cursor<'i, 'de>,
            ) -> Self::Output {
                let bytes = cursor.bytes();

                let mut serializer = self.serializer.serialize_tuple_variant(
                    header.name,
                    header.variant_index,
                    header.variant,
                    header.num,
                )?;

                let mut pos = cursor.pos();
                for _ in 0..header.num {
                    serializer.serialize_field(&SerializePart { bytes, pos })?;
                    pos = skip(bytes, pos);
                }

                serializer.end()
            }

            fn visit_struct_variant(
                self,
                header: StructVariantHeader,
                cursor: &mut Cursor<'i, 'de>,
            ) -> Self::Output {
                let bytes = cursor.bytes();

                let mut serializer = self.serializer.serialize_struct_variant(
                    header.name,
                    header.variant_index,
                    header.variant,
                    header.num,
                )?;

                let mut pos = cursor.pos();
                for _ in 0..header.num {
                    // SAFETY: As for `visit_struct`
                    let mut cursor = unsafe { Cursor::at(bytes, pos) };
                    let key = unsafe { cursor.read_field_key() };

                    serializer.serialize_field(
                        key,
                        &SerializePart {
                            bytes,
                            pos: cursor.pos(),
                        },
                    )?;
                    pos = skip(bytes, cursor.pos());
                }

                serializer.end()
            }
        }

        // SAFETY: `self.pos` is a part boundary, an invariant of
        // `SerializePart`
        unsafe { Cursor::at(self.bytes, self.pos).visit_part(SerializePartVisitor { serializer }) }
    }
}

/**
A serializer that produces [`Owned`] buffers from an arbitrary [`serde_core::Serialize`].
*/
pub struct Serializer(SerializeValue<SerializerState>);

impl Serializer {
    /**
    Create a new serializer for an [`Owned`] buffer.
    */
    pub fn new() -> Self {
        Serializer(SerializeValue {
            inner: SerializerState::new(),
        })
    }
}

pub struct SerializeSeq(SerializeCompound<SerializerState>);

pub struct SerializeTuple(SerializeCompound<SerializerState>);

pub struct SerializeTupleStruct(SerializeCompound<SerializerState>);

pub struct SerializeTupleVariant(SerializeCompound<SerializerState>);

pub struct SerializeMap(SerializeCompound<SerializerState>);

pub struct SerializeStruct(SerializeCompound<SerializerState>);

pub struct SerializeStructVariant(SerializeCompound<SerializerState>);

impl ser::Serializer for Serializer {
    type Ok = Owned;
    type Error = Error;
    type SerializeSeq = SerializeSeq;
    type SerializeTuple = SerializeTuple;
    type SerializeTupleStruct = SerializeTupleStruct;
    type SerializeTupleVariant = SerializeTupleVariant;
    type SerializeMap = SerializeMap;
    type SerializeStruct = SerializeStruct;
    type SerializeStructVariant = SerializeStructVariant;

    fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
        self.0.serialize_bool(v)
    }

    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
        self.0.serialize_i8(v)
    }

    fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
        self.0.serialize_i16(v)
    }

    fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
        self.0.serialize_i32(v)
    }

    fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
        self.0.serialize_i64(v)
    }

    fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error> {
        self.0.serialize_i128(v)
    }

    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
        self.0.serialize_u8(v)
    }

    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
        self.0.serialize_u16(v)
    }

    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
        self.0.serialize_u32(v)
    }

    fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
        self.0.serialize_u64(v)
    }

    fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error> {
        self.0.serialize_u128(v)
    }

    fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
        self.0.serialize_f32(v)
    }

    fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
        self.0.serialize_f64(v)
    }

    fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
        self.0.serialize_char(v)
    }

    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
        self.0.serialize_str(v)
    }

    fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
        self.0.serialize_bytes(v)
    }

    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
        self.0.serialize_none()
    }

    fn serialize_some<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
    where
        T: ?Sized + Serialize,
    {
        self.0.serialize_some(value)
    }

    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
        self.0.serialize_unit()
    }

    fn serialize_unit_struct(self, name: &'static str) -> Result<Self::Ok, Self::Error> {
        self.0.serialize_unit_struct(name)
    }

    fn serialize_unit_variant(
        self,
        name: &'static str,
        variant_index: u32,
        variant: &'static str,
    ) -> Result<Self::Ok, Self::Error> {
        self.0.serialize_unit_variant(name, variant_index, variant)
    }

    fn serialize_newtype_struct<T>(
        self,
        name: &'static str,
        value: &T,
    ) -> Result<Self::Ok, Self::Error>
    where
        T: ?Sized + Serialize,
    {
        self.0.serialize_newtype_struct(name, value)
    }

    fn serialize_newtype_variant<T>(
        self,
        name: &'static str,
        variant_index: u32,
        variant: &'static str,
        value: &T,
    ) -> Result<Self::Ok, Self::Error>
    where
        T: ?Sized + Serialize,
    {
        self.0
            .serialize_newtype_variant(name, variant_index, variant, value)
    }

    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
        Ok(SerializeSeq(self.0.serialize_seq(len)?))
    }

    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
        Ok(SerializeTuple(self.0.serialize_tuple(len)?))
    }

    fn serialize_tuple_struct(
        self,
        name: &'static str,
        len: usize,
    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
        Ok(SerializeTupleStruct(
            self.0.serialize_tuple_struct(name, len)?,
        ))
    }

    fn serialize_tuple_variant(
        self,
        name: &'static str,
        variant_index: u32,
        variant: &'static str,
        len: usize,
    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
        Ok(SerializeTupleVariant(self.0.serialize_tuple_variant(
            name,
            variant_index,
            variant,
            len,
        )?))
    }

    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
        Ok(SerializeMap(self.0.serialize_map(len)?))
    }

    fn serialize_struct(
        self,
        name: &'static str,
        len: usize,
    ) -> Result<Self::SerializeStruct, Self::Error> {
        Ok(SerializeStruct(self.0.serialize_struct(name, len)?))
    }

    fn serialize_struct_variant(
        self,
        name: &'static str,
        variant_index: u32,
        variant: &'static str,
        len: usize,
    ) -> Result<Self::SerializeStructVariant, Self::Error> {
        Ok(SerializeStructVariant(self.0.serialize_struct_variant(
            name,
            variant_index,
            variant,
            len,
        )?))
    }

    fn collect_seq<I>(self, iter: I) -> Result<Self::Ok, Self::Error>
    where
        I: IntoIterator,
        <I as IntoIterator>::Item: Serialize,
    {
        self.0.collect_seq(iter)
    }

    fn collect_map<K, V, I>(self, iter: I) -> Result<Self::Ok, Self::Error>
    where
        K: Serialize,
        V: Serialize,
        I: IntoIterator<Item = (K, V)>,
    {
        self.0.collect_map(iter)
    }

    fn collect_str<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
    where
        T: ?Sized + Display,
    {
        self.0.collect_str(value)
    }
}

impl ser::SerializeSeq for SerializeSeq {
    type Ok = Owned;
    type Error = Error;

    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
    where
        T: ?Sized + Serialize,
    {
        ser::SerializeSeq::serialize_element(&mut self.0, value)
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        ser::SerializeSeq::end(self.0)
    }
}

impl ser::SerializeTuple for SerializeTuple {
    type Ok = Owned;
    type Error = Error;

    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
    where
        T: ?Sized + Serialize,
    {
        ser::SerializeTuple::serialize_element(&mut self.0, value)
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        ser::SerializeTuple::end(self.0)
    }
}

impl ser::SerializeTupleStruct for SerializeTupleStruct {
    type Ok = Owned;
    type Error = Error;

    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
    where
        T: ?Sized + Serialize,
    {
        ser::SerializeTupleStruct::serialize_field(&mut self.0, value)
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        ser::SerializeTupleStruct::end(self.0)
    }
}

impl ser::SerializeTupleVariant for SerializeTupleVariant {
    type Ok = Owned;
    type Error = Error;

    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
    where
        T: ?Sized + Serialize,
    {
        ser::SerializeTupleVariant::serialize_field(&mut self.0, value)
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        ser::SerializeTupleVariant::end(self.0)
    }
}

impl ser::SerializeMap for SerializeMap {
    type Ok = Owned;
    type Error = Error;

    fn serialize_key<T>(&mut self, key: &T) -> Result<(), Self::Error>
    where
        T: ?Sized + Serialize,
    {
        ser::SerializeMap::serialize_key(&mut self.0, key)
    }

    fn serialize_value<T>(&mut self, value: &T) -> Result<(), Self::Error>
    where
        T: ?Sized + Serialize,
    {
        ser::SerializeMap::serialize_value(&mut self.0, value)
    }

    fn serialize_entry<K, V>(&mut self, key: &K, value: &V) -> Result<(), Self::Error>
    where
        K: ?Sized + Serialize,
        V: ?Sized + Serialize,
    {
        ser::SerializeMap::serialize_entry(&mut self.0, key, value)
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        ser::SerializeMap::end(self.0)
    }
}

impl ser::SerializeStruct for SerializeStruct {
    type Ok = Owned;
    type Error = Error;

    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
    where
        T: ?Sized + Serialize,
    {
        ser::SerializeStruct::serialize_field(&mut self.0, key, value)
    }

    fn skip_field(&mut self, key: &'static str) -> Result<(), Self::Error> {
        ser::SerializeStruct::skip_field(&mut self.0, key)
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        ser::SerializeStruct::end(self.0)
    }
}

impl ser::SerializeStructVariant for SerializeStructVariant {
    type Ok = Owned;
    type Error = Error;

    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
    where
        T: ?Sized + Serialize,
    {
        ser::SerializeStructVariant::serialize_field(&mut self.0, key, value)
    }

    fn skip_field(&mut self, key: &'static str) -> Result<(), Self::Error> {
        ser::SerializeStructVariant::skip_field(&mut self.0, key)
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        ser::SerializeStructVariant::end(self.0)
    }
}

/**
A serializer that produces [`Owned`] buffers from an arbitrary [`serde_core::Serialize`].
*/
struct SerializeValue<T> {
    inner: T,
}

struct SerializeCompound<T> {
    inner: T,
    frame: Frame,
}

trait SerializerStateOwner {
    type Ok;

    fn state_mut(&mut self) -> &mut SerializerState;

    fn end(self) -> Result<Self::Ok, Error>;
}

struct SerializerState {
    buf: PartBuf<'static, Vec<u8>>,
    // Whether a `Serialize` implementation that failed — by error, or by
    // panicking into a caller that caught the unwind — may have left a
    // partial part in the buffer
    poisoned: bool,
    // The number of containers begun but not yet ended
    depth: usize,
}

impl SerializerStateOwner for SerializerState {
    type Ok = Owned;

    fn state_mut(&mut self) -> &mut SerializerState {
        self
    }

    fn end(self) -> Result<Self::Ok, Error> {
        if !self.poisoned && self.depth == 0 {
            Ok(Owned(self.buf.into_boxed_slice()))
        } else {
            Err(ser::Error::custom(
                "a Serialize implementation left the buffer incomplete",
            ))
        }
    }
}

impl<'a> SerializerStateOwner for &'a mut SerializerState {
    type Ok = ();

    fn state_mut(&mut self) -> &mut SerializerState {
        *self
    }

    fn end(self) -> Result<Self::Ok, Error> {
        Ok(())
    }
}

impl SerializerState {
    #[inline]
    fn new() -> Self {
        SerializerState {
            buf: PartBuf::new(),
            poisoned: false,
            depth: 0,
        }
    }

    #[inline]
    fn buf_mut(&mut self) -> &mut PartBuf<'static, Vec<u8>> {
        &mut self.buf
    }

    // Container begin/end route through these inherent methods, shadowing
    // `Value`'s, so the open count can't be skipped
    #[inline(always)]
    fn begin_container(
        &mut self,
        begin: impl FnOnce(&mut PartBuf<'static, Vec<u8>>) -> Frame,
    ) -> Frame {
        self.depth += 1;

        begin(&mut self.buf)
    }

    #[inline]
    fn end_container(
        &mut self,
        frame: &Frame,
        end: impl FnOnce(&mut PartBuf<'static, Vec<u8>>, &Frame),
    ) -> Result<(), Error> {
        if frame.expect_value {
            return Err(ser::Error::custom("missing map value"));
        }

        debug_assert!(self.depth > 0, "attempt to end a container that isn't open");
        self.depth -= 1;

        end(&mut self.buf, frame);

        Ok(())
    }

    #[inline(always)]
    fn serialize<T: Serialize + ?Sized>(&mut self, v: &T) -> Result<(), Error> {
        // The slightly awkward mechanism for poisoning here is a performance
        // optimization. Typically, we'd just want to set `poisoned = true`,
        // then only set it back to `false` if we reached the end of the call.
        // In this case, `serialize` is hot, so we benefit from only writing to
        // `poisoned` if we actually have a reason to
        struct PoisonGuard(*mut SerializerState);

        impl PoisonGuard {
            // Poison on `Err`
            #[cold]
            fn poison(inner: &mut SerializerState, e: Error) -> Error {
                inner.poisoned = true;
                e
            }
        }

        // Poison on unwind
        impl Drop for PoisonGuard {
            fn drop(&mut self) {
                // SAFETY: The pointer came from the exclusive borrow of the
                // state below, and the borrow it lends to the value is
                // returned before the guard is dropped or forgotten
                unsafe { (*self.0).poisoned = true };
            }
        }

        let state: *mut SerializerState = self;
        let guard = PoisonGuard(state);

        // SAFETY: Reborrowed from the same pointer the guard holds, so a
        // panicking value unwinds through the guard while it's still valid
        let result = v.serialize(SerializeValue {
            inner: unsafe { &mut *state },
        });

        mem::forget(guard);

        match result {
            Ok(()) => Ok(()),
            Err(e) => Err(PoisonGuard::poison(self, e)),
        }
    }
}

impl<T: SerializerStateOwner> ser::Serializer for SerializeValue<T> {
    type Ok = T::Ok;
    type Error = Error;
    type SerializeSeq = SerializeCompound<T>;
    type SerializeTuple = SerializeCompound<T>;
    type SerializeTupleStruct = SerializeCompound<T>;
    type SerializeTupleVariant = SerializeCompound<T>;
    type SerializeMap = SerializeCompound<T>;
    type SerializeStruct = SerializeCompound<T>;
    type SerializeStructVariant = SerializeCompound<T>;

    fn serialize_bool(mut self, v: bool) -> Result<Self::Ok, Self::Error> {
        self.inner.state_mut().buf_mut().encode_bool(v);

        self.inner.end()
    }

    fn serialize_i8(mut self, v: i8) -> Result<Self::Ok, Self::Error> {
        self.inner.state_mut().buf_mut().encode_i8(v);

        self.inner.end()
    }

    fn serialize_i16(mut self, v: i16) -> Result<Self::Ok, Self::Error> {
        self.inner.state_mut().buf_mut().encode_i16(v);

        self.inner.end()
    }

    fn serialize_i32(mut self, v: i32) -> Result<Self::Ok, Self::Error> {
        self.inner.state_mut().buf_mut().encode_i32(v);

        self.inner.end()
    }

    fn serialize_i64(mut self, v: i64) -> Result<Self::Ok, Self::Error> {
        self.inner.state_mut().buf_mut().encode_i64(v);

        self.inner.end()
    }

    fn serialize_i128(mut self, v: i128) -> Result<Self::Ok, Self::Error> {
        self.inner.state_mut().buf_mut().encode_i128(v);

        self.inner.end()
    }

    fn serialize_u8(mut self, v: u8) -> Result<Self::Ok, Self::Error> {
        self.inner.state_mut().buf_mut().encode_u8(v);

        self.inner.end()
    }

    fn serialize_u16(mut self, v: u16) -> Result<Self::Ok, Self::Error> {
        self.inner.state_mut().buf_mut().encode_u16(v);

        self.inner.end()
    }

    fn serialize_u32(mut self, v: u32) -> Result<Self::Ok, Self::Error> {
        self.inner.state_mut().buf_mut().encode_u32(v);

        self.inner.end()
    }

    fn serialize_u64(mut self, v: u64) -> Result<Self::Ok, Self::Error> {
        self.inner.state_mut().buf_mut().encode_u64(v);

        self.inner.end()
    }

    fn serialize_u128(mut self, v: u128) -> Result<Self::Ok, Self::Error> {
        self.inner.state_mut().buf_mut().encode_u128(v);

        self.inner.end()
    }

    fn serialize_f32(mut self, v: f32) -> Result<Self::Ok, Self::Error> {
        self.inner.state_mut().buf_mut().encode_f32(v);

        self.inner.end()
    }

    fn serialize_f64(mut self, v: f64) -> Result<Self::Ok, Self::Error> {
        self.inner.state_mut().buf_mut().encode_f64(v);

        self.inner.end()
    }

    fn serialize_char(mut self, v: char) -> Result<Self::Ok, Self::Error> {
        self.inner.state_mut().buf_mut().encode_char(v);

        self.inner.end()
    }

    fn serialize_str(mut self, v: &str) -> Result<Self::Ok, Self::Error> {
        self.inner.state_mut().buf_mut().encode_str(v);

        self.inner.end()
    }

    fn serialize_bytes(mut self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
        self.inner.state_mut().buf_mut().encode_bytes(v);

        self.inner.end()
    }

    fn serialize_none(mut self) -> Result<Self::Ok, Self::Error> {
        self.inner.state_mut().buf_mut().encode_none();

        self.inner.end()
    }

    fn serialize_some<V: ?Sized>(mut self, value: &V) -> Result<Self::Ok, Self::Error>
    where
        V: Serialize,
    {
        self.inner.state_mut().buf_mut().encode_some();
        self.inner.state_mut().serialize(value)?;

        self.inner.end()
    }

    fn serialize_unit(mut self) -> Result<Self::Ok, Self::Error> {
        self.inner.state_mut().buf_mut().encode_unit();

        self.inner.end()
    }

    fn serialize_unit_struct(mut self, name: &'static str) -> Result<Self::Ok, Self::Error> {
        self.inner.state_mut().buf_mut().encode_unit_struct(name);

        self.inner.end()
    }

    fn serialize_unit_variant(
        mut self,
        name: &'static str,
        variant_index: u32,
        variant: &'static str,
    ) -> Result<Self::Ok, Self::Error> {
        self.inner
            .state_mut()
            .buf_mut()
            .encode_unit_variant(name, variant_index, variant);

        self.inner.end()
    }

    fn serialize_newtype_struct<V: ?Sized>(
        mut self,
        name: &'static str,
        value: &V,
    ) -> Result<Self::Ok, Self::Error>
    where
        V: Serialize,
    {
        self.inner.state_mut().buf_mut().encode_newtype_struct(name);
        self.inner.state_mut().serialize(value)?;

        self.inner.end()
    }

    fn serialize_newtype_variant<V: ?Sized>(
        mut self,
        name: &'static str,
        variant_index: u32,
        variant: &'static str,
        value: &V,
    ) -> Result<Self::Ok, Self::Error>
    where
        V: Serialize,
    {
        self.inner
            .state_mut()
            .buf_mut()
            .encode_newtype_variant(name, variant_index, variant);
        self.inner.state_mut().serialize(value)?;

        self.inner.end()
    }

    fn serialize_seq(mut self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
        let frame = self.inner.state_mut().begin_container(|v| v.begin_seq());

        Ok(SerializeCompound {
            inner: self.inner,
            frame,
        })
    }

    fn serialize_tuple(mut self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
        let frame = self.inner.state_mut().begin_container(|v| v.begin_tuple());

        Ok(SerializeCompound {
            inner: self.inner,
            frame,
        })
    }

    fn serialize_tuple_struct(
        mut self,
        name: &'static str,
        _len: usize,
    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
        let frame = self
            .inner
            .state_mut()
            .begin_container(|v| v.begin_tuple_struct(name));

        Ok(SerializeCompound {
            inner: self.inner,
            frame,
        })
    }

    fn serialize_tuple_variant(
        mut self,
        name: &'static str,
        variant_index: u32,
        variant: &'static str,
        _len: usize,
    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
        let frame = self
            .inner
            .state_mut()
            .begin_container(|v| v.begin_tuple_variant(name, variant_index, variant));

        Ok(SerializeCompound {
            inner: self.inner,
            frame,
        })
    }

    fn serialize_map(mut self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
        let frame = self.inner.state_mut().begin_container(|v| v.begin_map());

        Ok(SerializeCompound {
            inner: self.inner,
            frame,
        })
    }

    fn serialize_struct(
        mut self,
        name: &'static str,
        _len: usize,
    ) -> Result<Self::SerializeStruct, Self::Error> {
        let frame = self
            .inner
            .state_mut()
            .begin_container(|v| v.begin_struct(name));

        Ok(SerializeCompound {
            inner: self.inner,
            frame,
        })
    }

    fn serialize_struct_variant(
        mut self,
        name: &'static str,
        variant_index: u32,
        variant: &'static str,
        _len: usize,
    ) -> Result<Self::SerializeStructVariant, Self::Error> {
        let frame = self
            .inner
            .state_mut()
            .begin_container(|v| v.begin_struct_variant(name, variant_index, variant));

        Ok(SerializeCompound {
            inner: self.inner,
            frame,
        })
    }
}

impl<T: SerializerStateOwner> ser::SerializeSeq for SerializeCompound<T> {
    type Ok = T::Ok;
    type Error = Error;

    fn serialize_element<E: ?Sized>(&mut self, value: &E) -> Result<(), Self::Error>
    where
        E: Serialize,
    {
        self.frame.num += 1;
        self.inner.state_mut().serialize(value)
    }

    fn end(mut self) -> Result<Self::Ok, Self::Error> {
        self.inner
            .state_mut()
            .end_container(&mut self.frame, |value, frame| value.end_seq(frame))?;
        self.inner.end()
    }
}

impl<T: SerializerStateOwner> ser::SerializeTuple for SerializeCompound<T> {
    type Ok = T::Ok;
    type Error = Error;

    fn serialize_element<F: ?Sized>(&mut self, value: &F) -> Result<(), Self::Error>
    where
        F: Serialize,
    {
        self.frame.num += 1;
        self.inner.state_mut().serialize(value)
    }

    fn end(mut self) -> Result<Self::Ok, Self::Error> {
        self.inner
            .state_mut()
            .end_container(&mut self.frame, |value, frame| value.end_tuple(frame))?;
        self.inner.end()
    }
}

impl<T: SerializerStateOwner> ser::SerializeTupleStruct for SerializeCompound<T> {
    type Ok = T::Ok;
    type Error = Error;

    fn serialize_field<F: ?Sized>(&mut self, value: &F) -> Result<(), Self::Error>
    where
        F: Serialize,
    {
        self.frame.num += 1;
        self.inner.state_mut().serialize(value)
    }

    fn end(mut self) -> Result<Self::Ok, Self::Error> {
        self.inner
            .state_mut()
            .end_container(&mut self.frame, |value, frame| {
                value.end_tuple_struct(frame)
            })?;
        self.inner.end()
    }
}

impl<T: SerializerStateOwner> ser::SerializeTupleVariant for SerializeCompound<T> {
    type Ok = T::Ok;
    type Error = Error;

    fn serialize_field<F: ?Sized>(&mut self, value: &F) -> Result<(), Self::Error>
    where
        F: Serialize,
    {
        self.frame.num += 1;
        self.inner.state_mut().serialize(value)
    }

    fn end(mut self) -> Result<Self::Ok, Self::Error> {
        self.inner
            .state_mut()
            .end_container(&mut self.frame, |value, frame| {
                value.end_tuple_variant(frame)
            })?;
        self.inner.end()
    }
}

impl<T: SerializerStateOwner> ser::SerializeMap for SerializeCompound<T> {
    type Ok = T::Ok;
    type Error = Error;

    fn serialize_key<K: ?Sized>(&mut self, key: &K) -> Result<(), Self::Error>
    where
        K: Serialize,
    {
        if self.frame.expect_value {
            return Err(ser::Error::custom("missing map value"));
        }

        self.frame.expect_value = true;
        self.inner.state_mut().serialize(key)
    }

    fn serialize_value<V: ?Sized>(&mut self, value: &V) -> Result<(), Self::Error>
    where
        V: Serialize,
    {
        if !self.frame.expect_value {
            return Err(ser::Error::custom("missing map key"));
        }

        self.frame.expect_value = false;
        self.frame.num += 1;
        self.inner.state_mut().serialize(value)
    }

    fn end(mut self) -> Result<Self::Ok, Self::Error> {
        self.inner
            .state_mut()
            .end_container(&mut self.frame, |value, frame| value.end_map(frame))?;
        self.inner.end()
    }
}

impl<T: SerializerStateOwner> ser::SerializeStruct for SerializeCompound<T> {
    type Ok = T::Ok;
    type Error = Error;

    fn serialize_field<F: ?Sized>(
        &mut self,
        key: &'static str,
        value: &F,
    ) -> Result<(), Self::Error>
    where
        F: Serialize,
    {
        self.frame.num += 1;
        self.inner.state_mut().buf_mut().push_field_key(key);
        self.inner.state_mut().serialize(value)
    }

    fn end(mut self) -> Result<Self::Ok, Self::Error> {
        self.inner
            .state_mut()
            .end_container(&mut self.frame, |value, frame| value.end_struct(frame))?;
        self.inner.end()
    }
}

impl<T: SerializerStateOwner> ser::SerializeStructVariant for SerializeCompound<T> {
    type Ok = T::Ok;
    type Error = Error;

    fn serialize_field<F: ?Sized>(
        &mut self,
        key: &'static str,
        value: &F,
    ) -> Result<(), Self::Error>
    where
        F: Serialize,
    {
        self.frame.num += 1;
        self.inner.state_mut().buf_mut().push_field_key(key);
        self.inner.state_mut().serialize(value)
    }

    fn end(mut self) -> Result<Self::Ok, Self::Error> {
        self.inner
            .state_mut()
            .end_container(&mut self.frame, |value, frame| {
                value.end_struct_variant(frame)
            })?;
        self.inner.end()
    }
}