Method deserialize_tuple

src/serde/de.rs:304–382

(mut self, tuple_len: usize, v: V)

    #[inline(always)]
    fn deserialize_tuple<V>(mut self, tuple_len: usize, v: V) -> Result<V::Value>
    where
        V: Visitor<'de>,
    {
        // Fast path: avoid overhead of tuple for 1 element.
        if tuple_len == 1 {
            return v.visit_seq(Access {
                decoders: std::slice::from_mut(self.decoder),
                input: self.input,
                index: 0,
            });
        }

        // Copy of specify! macro that takes an additional tuple_len parameter to cold.
        match &mut self.decoder {
            SerdeDecoder::Tuple(_) => (),
            _ => {
                #[cold]
                fn cold<'de>(
                    decoder: &mut SerdeDecoder<'de>,
                    input: &mut &'de [u8],
                    tuple_len: usize,
                ) -> Result<()> {
                    let &mut SerdeDecoder::Unspecified { length } = decoder else {
                        type_changed!();
                    };
                    *decoder = SerdeDecoder::Tuple(default_box_slice(tuple_len));
                    decoder.populate(input, length)
                }
                cold(&mut *self.decoder, &mut *self.input, tuple_len)?;
            }
        }
        let SerdeDecoder::Tuple(decoders) = &mut *self.decoder else {
            // Safety: see specify! macro which this is based on.
            unsafe { std::hint::unreachable_unchecked() };
        };
        if decoders.len() != tuple_len {
            type_changed!(); // Removes multiple bounds checks.
        }

        struct Access<'a, 'de> {
            decoders: &'a mut [SerdeDecoder<'de>],
            input: &'a mut &'de [u8],
            index: usize,
        }
        impl<'de> SeqAccess<'de> for Access<'_, 'de> {
            type Error = Error;

            #[inline(always)]
            fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
            where
                T: DeserializeSeed<'de>,
            {
                if let Some(decoder) = self.decoders.get_mut(self.index) {
                    self.index += 1;
                    Ok(Some(DeserializeSeed::deserialize(
                        seed,
                        DecoderWrapper {