dbt_yaml/value/de/
borrowed.rs

1use std::{collections::HashSet, slice};
2
3use serde::{
4    de::{
5        value::BorrowedStrDeserializer, DeserializeSeed, EnumAccess, Error as _, MapAccess,
6        SeqAccess, Unexpected, VariantAccess, Visitor,
7    },
8    forward_to_deserialize_any, Deserialize, Deserializer,
9};
10
11use crate::{
12    error,
13    value::{
14        de::{reset_is_deserializing_value, save_deserializer_state, ValueDeserializer},
15        tagged,
16    },
17    Error, Mapping, Path, Sequence, Value,
18};
19
20use super::{FieldTransformer, UnusedKeyCallback};
21
22fn visit_sequence_ref<'de, 'p, 'u, 'f, V>(
23    sequence: &'de Sequence,
24    current_path: Path<'p>,
25    visitor: V,
26    unused_key_callback: Option<UnusedKeyCallback<'u>>,
27    field_transformer: Option<FieldTransformer<'f>>,
28) -> Result<V::Value, Error>
29where
30    V: Visitor<'de>,
31{
32    let len = sequence.len();
33    let mut deserializer = SeqRefDeserializer::new_with(
34        sequence,
35        current_path,
36        unused_key_callback,
37        field_transformer,
38    );
39    let seq = visitor.visit_seq(&mut deserializer)?;
40    let remaining = deserializer.iter.len();
41    if remaining == 0 {
42        Ok(seq)
43    } else {
44        Err(Error::invalid_length(len, &"fewer elements in sequence"))
45    }
46}
47
48fn visit_mapping_ref<'de, 'p, 'u, 'f, V>(
49    mapping: &'de Mapping,
50    current_path: Path<'p>,
51    visitor: V,
52    unused_key_callback: Option<UnusedKeyCallback<'u>>,
53    field_transformer: Option<FieldTransformer<'f>>,
54) -> Result<V::Value, Error>
55where
56    V: Visitor<'de>,
57{
58    let len = mapping.len();
59    let mut deserializer = MapRefDeserializer::new_with(
60        mapping,
61        current_path,
62        unused_key_callback,
63        field_transformer,
64    );
65    let map = visitor.visit_map(&mut deserializer)?;
66    let has_remaining = deserializer.iter.unwrap().next().is_some();
67    if !has_remaining {
68        Ok(map)
69    } else {
70        Err(Error::invalid_length(len, &"fewer elements in map"))
71    }
72}
73
74fn visit_struct_ref<'de, 'p, 'u, 'f, V>(
75    mapping: &'de Mapping,
76    current_path: Path<'p>,
77    visitor: V,
78    known_keys: &'static [&'static str],
79    unused_key_callback: Option<UnusedKeyCallback<'u>>,
80    field_transformer: Option<FieldTransformer<'f>>,
81) -> Result<V::Value, Error>
82where
83    V: Visitor<'de>,
84{
85    let len = mapping.len();
86    let mut deserializer = StructRefDeserializer::new_with(
87        mapping,
88        current_path,
89        known_keys,
90        unused_key_callback,
91        field_transformer,
92    );
93    let map = visitor.visit_map(&mut deserializer)?;
94    let has_remaining =
95        deserializer.iter.unwrap().next().is_some() || !deserializer.rest.is_empty();
96    if !has_remaining {
97        Ok(map)
98    } else {
99        Err(Error::invalid_length(len, &"fewer elements in struct"))
100    }
101}
102
103impl<'de> Deserializer<'de> for &'de Value {
104    type Error = Error;
105
106    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
107    where
108        V: Visitor<'de>,
109    {
110        ValueRefDeserializer::new(self).deserialize_any(visitor)
111    }
112
113    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Error>
114    where
115        V: Visitor<'de>,
116    {
117        ValueRefDeserializer::new(self).deserialize_bool(visitor)
118    }
119
120    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Error>
121    where
122        V: Visitor<'de>,
123    {
124        ValueRefDeserializer::new(self).deserialize_i8(visitor)
125    }
126
127    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Error>
128    where
129        V: Visitor<'de>,
130    {
131        ValueRefDeserializer::new(self).deserialize_i16(visitor)
132    }
133
134    fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Error>
135    where
136        V: Visitor<'de>,
137    {
138        ValueRefDeserializer::new(self).deserialize_i32(visitor)
139    }
140
141    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Error>
142    where
143        V: Visitor<'de>,
144    {
145        ValueRefDeserializer::new(self).deserialize_i64(visitor)
146    }
147
148    fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value, Error>
149    where
150        V: Visitor<'de>,
151    {
152        ValueRefDeserializer::new(self).deserialize_i128(visitor)
153    }
154
155    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Error>
156    where
157        V: Visitor<'de>,
158    {
159        ValueRefDeserializer::new(self).deserialize_u8(visitor)
160    }
161
162    fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Error>
163    where
164        V: Visitor<'de>,
165    {
166        ValueRefDeserializer::new(self).deserialize_u16(visitor)
167    }
168
169    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Error>
170    where
171        V: Visitor<'de>,
172    {
173        ValueRefDeserializer::new(self).deserialize_u32(visitor)
174    }
175
176    fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Error>
177    where
178        V: Visitor<'de>,
179    {
180        ValueRefDeserializer::new(self).deserialize_u64(visitor)
181    }
182
183    fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value, Error>
184    where
185        V: Visitor<'de>,
186    {
187        ValueRefDeserializer::new(self).deserialize_u128(visitor)
188    }
189
190    fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Error>
191    where
192        V: Visitor<'de>,
193    {
194        ValueRefDeserializer::new(self).deserialize_f32(visitor)
195    }
196
197    fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Error>
198    where
199        V: Visitor<'de>,
200    {
201        ValueRefDeserializer::new(self).deserialize_f64(visitor)
202    }
203
204    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Error>
205    where
206        V: Visitor<'de>,
207    {
208        ValueRefDeserializer::new(self).deserialize_char(visitor)
209    }
210
211    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Error>
212    where
213        V: Visitor<'de>,
214    {
215        ValueRefDeserializer::new(self).deserialize_str(visitor)
216    }
217
218    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Error>
219    where
220        V: Visitor<'de>,
221    {
222        ValueRefDeserializer::new(self).deserialize_string(visitor)
223    }
224
225    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Error>
226    where
227        V: Visitor<'de>,
228    {
229        ValueRefDeserializer::new(self).deserialize_bytes(visitor)
230    }
231
232    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Error>
233    where
234        V: Visitor<'de>,
235    {
236        ValueRefDeserializer::new(self).deserialize_byte_buf(visitor)
237    }
238
239    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
240    where
241        V: Visitor<'de>,
242    {
243        ValueRefDeserializer::new(self).deserialize_option(visitor)
244    }
245
246    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Error>
247    where
248        V: Visitor<'de>,
249    {
250        ValueRefDeserializer::new(self).deserialize_unit(visitor)
251    }
252
253    fn deserialize_unit_struct<V>(self, name: &'static str, visitor: V) -> Result<V::Value, Error>
254    where
255        V: Visitor<'de>,
256    {
257        ValueRefDeserializer::new(self).deserialize_unit_struct(name, visitor)
258    }
259
260    fn deserialize_newtype_struct<V>(
261        self,
262        name: &'static str,
263        visitor: V,
264    ) -> Result<V::Value, Error>
265    where
266        V: Visitor<'de>,
267    {
268        ValueRefDeserializer::new(self).deserialize_newtype_struct(name, visitor)
269    }
270
271    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Error>
272    where
273        V: Visitor<'de>,
274    {
275        ValueRefDeserializer::new(self).deserialize_seq(visitor)
276    }
277
278    fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Error>
279    where
280        V: Visitor<'de>,
281    {
282        ValueRefDeserializer::new(self).deserialize_tuple(_len, visitor)
283    }
284
285    fn deserialize_tuple_struct<V>(
286        self,
287        name: &'static str,
288        len: usize,
289        visitor: V,
290    ) -> Result<V::Value, Error>
291    where
292        V: Visitor<'de>,
293    {
294        ValueRefDeserializer::new(self).deserialize_tuple_struct(name, len, visitor)
295    }
296
297    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Error>
298    where
299        V: Visitor<'de>,
300    {
301        ValueRefDeserializer::new(self).deserialize_map(visitor)
302    }
303
304    fn deserialize_struct<V>(
305        self,
306        name: &'static str,
307        fields: &'static [&'static str],
308        visitor: V,
309    ) -> Result<V::Value, Error>
310    where
311        V: Visitor<'de>,
312    {
313        ValueRefDeserializer::new(self).deserialize_struct(name, fields, visitor)
314    }
315
316    fn deserialize_enum<V>(
317        self,
318        name: &'static str,
319        variants: &'static [&'static str],
320        visitor: V,
321    ) -> Result<V::Value, Error>
322    where
323        V: Visitor<'de>,
324    {
325        ValueRefDeserializer::new(self).deserialize_enum(name, variants, visitor)
326    }
327
328    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Error>
329    where
330        V: Visitor<'de>,
331    {
332        ValueRefDeserializer::new(self).deserialize_identifier(visitor)
333    }
334
335    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Error>
336    where
337        V: Visitor<'de>,
338    {
339        ValueRefDeserializer::new(self).deserialize_ignored_any(visitor)
340    }
341}
342
343pub struct ValueRefDeserializer<'de, 'p, 'u, 'f> {
344    value: &'de Value,
345    path: Path<'p>,
346    unused_key_callback: Option<UnusedKeyCallback<'u>>,
347    field_transformer: Option<FieldTransformer<'f>>,
348    // Flag indicating whether the value has been already been transformed by
349    // field_transformer:
350    is_transformed: bool,
351}
352
353impl<'de> ValueRefDeserializer<'de, '_, '_, '_> {
354    pub(crate) fn new(value: &'de Value) -> Self {
355        ValueRefDeserializer::new_with(value, Path::Root, None, None)
356    }
357}
358
359impl<'de, 'p, 'u, 'f> ValueRefDeserializer<'de, 'p, 'u, 'f> {
360    pub(crate) fn new_with(
361        value: &'de Value,
362        path: Path<'p>,
363        unused_key_callback: Option<UnusedKeyCallback<'u>>,
364        field_transformer: Option<FieldTransformer<'f>>,
365    ) -> Self {
366        value.broadcast_start_mark();
367
368        ValueRefDeserializer {
369            value,
370            path,
371            unused_key_callback,
372            field_transformer,
373            is_transformed: false,
374        }
375    }
376
377    pub(crate) fn new_with_transformed(
378        value: &'de Value,
379        path: Path<'p>,
380        unused_key_callback: Option<UnusedKeyCallback<'u>>,
381        field_transformer: Option<FieldTransformer<'f>>,
382    ) -> Self {
383        ValueRefDeserializer {
384            value,
385            path,
386            unused_key_callback,
387            field_transformer,
388            is_transformed: true,
389        }
390    }
391}
392
393macro_rules! maybe_transform_and_forward_to_value_deserializer {
394    ($self:expr, $method:ident, $($args:expr),*) => {
395        if let Some(transformer) = &mut $self.field_transformer {
396            if !$self.is_transformed && crate::verbatim::should_transform_any() {
397                if let Some(v) = transformer(&$self.value).map_err(|err| {
398                    let err = Error::from(err);
399                    if $crate::shouldbe::is_expecting_should_be_then_reset() {
400                        let msg = err.to_string();
401                        $crate::shouldbe::set_why_not($self.value.clone(), err);
402                        // This error will be ignored by ShouldBe, but we still have to
403                        // return an error here nonetheless.
404                        Error::custom(msg)
405                    } else {
406                        err
407                    }
408                })? {
409                    return ValueDeserializer::new_with_transformed(
410                        v,
411                        $self.path,
412                        $self.unused_key_callback,
413                        $self.field_transformer,
414                    )
415                    .$method($($args),*);
416                }
417            }
418        }
419    };
420}
421
422use super::maybe_why_not;
423
424impl<'de, 'u, 'f> Deserializer<'de> for ValueRefDeserializer<'de, '_, 'u, 'f> {
425    type Error = Error;
426
427    fn deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Error>
428    where
429        V: Visitor<'de>,
430    {
431        let span = self.value.span().clone();
432        self.value.broadcast_end_mark();
433        if super::should_short_circuit_any(self.field_transformer.is_some()) {
434            // SAFETY: self.unused_key_callback and self.field_transformer are
435            // passed in from outside and guaranteed to be valid for 'de
436            unsafe {
437                save_deserializer_state(
438                    Some(self.value.clone()),
439                    self.path,
440                    self.unused_key_callback,
441                    self.field_transformer,
442                );
443            }
444            return Err(Error::custom("Value deserialized via fast path"));
445        }
446        maybe_transform_and_forward_to_value_deserializer!(self, deserialize_any, visitor);
447
448        maybe_why_not!(
449            self.value,
450            match self.value {
451                Value::Null(..) => visitor.visit_unit(),
452                Value::Bool(v, ..) => visitor.visit_bool(*v),
453                Value::Number(n, ..) => n.deserialize_any(visitor),
454                Value::String(v, ..) => visitor.visit_borrowed_str(v),
455                Value::Sequence(v, ..) => visit_sequence_ref(
456                    v,
457                    self.path,
458                    visitor,
459                    self.unused_key_callback,
460                    self.field_transformer,
461                ),
462                Value::Mapping(v, ..) => visit_mapping_ref(
463                    v,
464                    self.path,
465                    visitor,
466                    self.unused_key_callback,
467                    self.field_transformer,
468                ),
469                Value::Tagged(tagged, ..) => visitor.visit_enum(&**tagged),
470            }
471            .map_err(|e| error::set_span(e, span))
472        )
473    }
474
475    fn deserialize_bool<V>(mut self, visitor: V) -> Result<V::Value, Error>
476    where
477        V: Visitor<'de>,
478    {
479        maybe_transform_and_forward_to_value_deserializer!(self, deserialize_bool, visitor);
480
481        let span = self.value.span().clone();
482        self.value.broadcast_end_mark();
483        maybe_why_not!(
484            self.value,
485            match self.value.untag_ref() {
486                Value::Bool(v, ..) => visitor.visit_bool(*v),
487                other => Err(other.invalid_type(&visitor)),
488            }
489            .map_err(|e| error::set_span(e, span))
490        )
491    }
492
493    fn deserialize_i8<V>(mut self, visitor: V) -> Result<V::Value, Error>
494    where
495        V: Visitor<'de>,
496    {
497        maybe_transform_and_forward_to_value_deserializer!(self, deserialize_i8, visitor);
498
499        self.value.deserialize_number(visitor)
500    }
501
502    fn deserialize_i16<V>(mut self, visitor: V) -> Result<V::Value, Error>
503    where
504        V: Visitor<'de>,
505    {
506        maybe_transform_and_forward_to_value_deserializer!(self, deserialize_i16, visitor);
507
508        self.value.deserialize_number(visitor)
509    }
510
511    fn deserialize_i32<V>(mut self, visitor: V) -> Result<V::Value, Error>
512    where
513        V: Visitor<'de>,
514    {
515        maybe_transform_and_forward_to_value_deserializer!(self, deserialize_i32, visitor);
516
517        self.value.deserialize_number(visitor)
518    }
519
520    fn deserialize_i64<V>(mut self, visitor: V) -> Result<V::Value, Error>
521    where
522        V: Visitor<'de>,
523    {
524        maybe_transform_and_forward_to_value_deserializer!(self, deserialize_i64, visitor);
525
526        self.value.deserialize_number(visitor)
527    }
528
529    fn deserialize_i128<V>(mut self, visitor: V) -> Result<V::Value, Error>
530    where
531        V: Visitor<'de>,
532    {
533        maybe_transform_and_forward_to_value_deserializer!(self, deserialize_i128, visitor);
534
535        self.value.deserialize_number(visitor)
536    }
537
538    fn deserialize_u8<V>(mut self, visitor: V) -> Result<V::Value, Error>
539    where
540        V: Visitor<'de>,
541    {
542        maybe_transform_and_forward_to_value_deserializer!(self, deserialize_u8, visitor);
543
544        self.value.deserialize_number(visitor)
545    }
546
547    fn deserialize_u16<V>(mut self, visitor: V) -> Result<V::Value, Error>
548    where
549        V: Visitor<'de>,
550    {
551        maybe_transform_and_forward_to_value_deserializer!(self, deserialize_u16, visitor);
552
553        self.value.deserialize_number(visitor)
554    }
555
556    fn deserialize_u32<V>(mut self, visitor: V) -> Result<V::Value, Error>
557    where
558        V: Visitor<'de>,
559    {
560        maybe_transform_and_forward_to_value_deserializer!(self, deserialize_u32, visitor);
561
562        self.value.deserialize_number(visitor)
563    }
564
565    fn deserialize_u64<V>(mut self, visitor: V) -> Result<V::Value, Error>
566    where
567        V: Visitor<'de>,
568    {
569        maybe_transform_and_forward_to_value_deserializer!(self, deserialize_u64, visitor);
570
571        self.value.deserialize_number(visitor)
572    }
573
574    fn deserialize_u128<V>(mut self, visitor: V) -> Result<V::Value, Error>
575    where
576        V: Visitor<'de>,
577    {
578        maybe_transform_and_forward_to_value_deserializer!(self, deserialize_u128, visitor);
579
580        self.value.deserialize_number(visitor)
581    }
582
583    fn deserialize_f32<V>(mut self, visitor: V) -> Result<V::Value, Error>
584    where
585        V: Visitor<'de>,
586    {
587        maybe_transform_and_forward_to_value_deserializer!(self, deserialize_f32, visitor);
588
589        self.value.deserialize_number(visitor)
590    }
591
592    fn deserialize_f64<V>(mut self, visitor: V) -> Result<V::Value, Error>
593    where
594        V: Visitor<'de>,
595    {
596        maybe_transform_and_forward_to_value_deserializer!(self, deserialize_f64, visitor);
597
598        self.value.deserialize_number(visitor)
599    }
600
601    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Error>
602    where
603        V: Visitor<'de>,
604    {
605        self.deserialize_str(visitor)
606    }
607
608    fn deserialize_str<V>(mut self, visitor: V) -> Result<V::Value, Error>
609    where
610        V: Visitor<'de>,
611    {
612        maybe_transform_and_forward_to_value_deserializer!(self, deserialize_str, visitor);
613
614        let span = self.value.span().clone();
615        self.value.broadcast_end_mark();
616        maybe_why_not!(
617            self.value,
618            match self.value.untag_ref() {
619                Value::String(v, ..) => visitor.visit_borrowed_str(v),
620                other => Err(other.invalid_type(&visitor)),
621            }
622            .map_err(|e| error::set_span(e, span))
623        )
624    }
625
626    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Error>
627    where
628        V: Visitor<'de>,
629    {
630        self.deserialize_str(visitor)
631    }
632
633    fn deserialize_bytes<V>(mut self, visitor: V) -> Result<V::Value, Error>
634    where
635        V: Visitor<'de>,
636    {
637        maybe_transform_and_forward_to_value_deserializer!(self, deserialize_bytes, visitor);
638
639        let span = self.value.span().clone();
640        self.value.broadcast_end_mark();
641        maybe_why_not!(
642            self.value,
643            match self.value.untag_ref() {
644                Value::String(v, ..) => visitor.visit_borrowed_str(v),
645                Value::Sequence(v, ..) => visit_sequence_ref(
646                    v,
647                    self.path,
648                    visitor,
649                    self.unused_key_callback,
650                    self.field_transformer,
651                ),
652                other => Err(other.invalid_type(&visitor)),
653            }
654            .map_err(|e| error::set_span(e, span))
655        )
656    }
657
658    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Error>
659    where
660        V: Visitor<'de>,
661    {
662        self.deserialize_bytes(visitor)
663    }
664
665    fn deserialize_option<V>(mut self, visitor: V) -> Result<V::Value, Error>
666    where
667        V: Visitor<'de>,
668    {
669        maybe_transform_and_forward_to_value_deserializer!(self, deserialize_option, visitor);
670
671        let span = self.value.span().clone();
672        maybe_why_not!(
673            self.value,
674            match self.value {
675                Value::Null(..) => visitor.visit_unit(),
676                _ => visitor.visit_some(ValueRefDeserializer::new_with_transformed(
677                    self.value,
678                    self.path,
679                    self.unused_key_callback,
680                    self.field_transformer,
681                )),
682            }
683            .map_err(|e| error::set_span(e, span))
684        )
685    }
686
687    fn deserialize_unit<V>(mut self, visitor: V) -> Result<V::Value, Error>
688    where
689        V: Visitor<'de>,
690    {
691        maybe_transform_and_forward_to_value_deserializer!(self, deserialize_unit, visitor);
692
693        let span = self.value.span().clone();
694        self.value.broadcast_end_mark();
695        maybe_why_not!(
696            self.value,
697            match self.value {
698                Value::Null(..) => visitor.visit_unit(),
699                _ => Err(self.value.invalid_type(&visitor)),
700            }
701            .map_err(|e| error::set_span(e, span))
702        )
703    }
704
705    fn deserialize_unit_struct<V>(
706        mut self,
707        name: &'static str,
708        visitor: V,
709    ) -> Result<V::Value, Error>
710    where
711        V: Visitor<'de>,
712    {
713        maybe_transform_and_forward_to_value_deserializer!(
714            self,
715            deserialize_unit_struct,
716            name,
717            visitor
718        );
719
720        self.deserialize_unit(visitor)
721    }
722
723    fn deserialize_newtype_struct<V>(
724        mut self,
725        name: &'static str,
726        visitor: V,
727    ) -> Result<V::Value, Error>
728    where
729        V: Visitor<'de>,
730    {
731        maybe_transform_and_forward_to_value_deserializer!(
732            self,
733            deserialize_newtype_struct,
734            name,
735            visitor
736        );
737
738        let span = self.value.span().clone();
739        self.value.broadcast_end_mark();
740        maybe_why_not!(
741            self.value,
742            visitor
743                .visit_newtype_struct(ValueRefDeserializer::new_with_transformed(
744                    self.value,
745                    self.path,
746                    self.unused_key_callback,
747                    self.field_transformer
748                ))
749                .map_err(|e| error::set_span(e, span))
750        )
751    }
752
753    fn deserialize_seq<V>(mut self, visitor: V) -> Result<V::Value, Error>
754    where
755        V: Visitor<'de>,
756    {
757        static EMPTY: Sequence = Sequence::new();
758
759        maybe_transform_and_forward_to_value_deserializer!(self, deserialize_seq, visitor);
760
761        let span = self.value.span().clone();
762        self.value.broadcast_end_mark();
763        maybe_why_not!(
764            self.value,
765            match self.value.untag_ref() {
766                Value::Sequence(v, ..) => visit_sequence_ref(
767                    v,
768                    self.path,
769                    visitor,
770                    self.unused_key_callback,
771                    self.field_transformer,
772                ),
773                Value::Null(..) => visit_sequence_ref(
774                    &EMPTY,
775                    self.path,
776                    visitor,
777                    self.unused_key_callback,
778                    self.field_transformer,
779                ),
780                other => Err(other.invalid_type(&visitor)),
781            }
782            .map_err(|e| error::set_span(e, span))
783        )
784    }
785
786    fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Error>
787    where
788        V: Visitor<'de>,
789    {
790        self.deserialize_seq(visitor)
791    }
792
793    fn deserialize_tuple_struct<V>(
794        self,
795        _name: &'static str,
796        _len: usize,
797        visitor: V,
798    ) -> Result<V::Value, Error>
799    where
800        V: Visitor<'de>,
801    {
802        self.deserialize_seq(visitor)
803    }
804
805    fn deserialize_map<V>(mut self, visitor: V) -> Result<V::Value, Error>
806    where
807        V: Visitor<'de>,
808    {
809        maybe_transform_and_forward_to_value_deserializer!(self, deserialize_map, visitor);
810
811        let span = self.value.span().clone();
812        self.value.broadcast_end_mark();
813        maybe_why_not!(
814            self.value,
815            match self.value.untag_ref() {
816                Value::Mapping(v, ..) => visit_mapping_ref(
817                    v,
818                    self.path,
819                    visitor,
820                    self.unused_key_callback,
821                    self.field_transformer,
822                ),
823                Value::Null(..) => visitor.visit_map(&mut MapRefDeserializer::new_empty(self.path)),
824                other => Err(other.invalid_type(&visitor)),
825            }
826            .map_err(|e| error::set_span(e, span))
827        )
828    }
829
830    fn deserialize_struct<V>(
831        mut self,
832        name: &'static str,
833        fields: &'static [&'static str],
834        visitor: V,
835    ) -> Result<V::Value, Error>
836    where
837        V: Visitor<'de>,
838    {
839        maybe_transform_and_forward_to_value_deserializer!(
840            self,
841            deserialize_struct,
842            name,
843            fields,
844            visitor
845        );
846
847        let span = self.value.span().clone();
848        self.value.broadcast_end_mark();
849        maybe_why_not!(
850            self.value,
851            match self.value.untag_ref() {
852                Value::Mapping(v, ..) => visit_struct_ref(
853                    v,
854                    self.path,
855                    visitor,
856                    fields,
857                    self.unused_key_callback,
858                    self.field_transformer,
859                ),
860                Value::Null(..) => visitor.visit_map(&mut MapRefDeserializer::new_empty(self.path)),
861                other => Err(other.invalid_type(&visitor)),
862            }
863            .map_err(|e| error::set_span(e, span))
864        )
865    }
866
867    fn deserialize_enum<V>(
868        mut self,
869        name: &'static str,
870        variants: &'static [&'static str],
871        visitor: V,
872    ) -> Result<V::Value, Error>
873    where
874        V: Visitor<'de>,
875    {
876        maybe_transform_and_forward_to_value_deserializer!(
877            self,
878            deserialize_enum,
879            name,
880            variants,
881            visitor
882        );
883
884        let span = self.value.span().clone();
885        self.value.broadcast_end_mark();
886        maybe_why_not!(
887            self.value,
888            visitor
889                .visit_enum(match self.value {
890                    Value::Tagged(tagged, ..) => EnumRefDeserializer {
891                        tag: tagged::nobang(&tagged.tag.string),
892                        path: self.path,
893                        value: Some(&tagged.value),
894                        unused_key_callback: self.unused_key_callback,
895                        field_transformer: self.field_transformer,
896                    },
897                    Value::String(variant, ..) => EnumRefDeserializer {
898                        tag: variant,
899                        path: self.path,
900                        value: None,
901                        unused_key_callback: self.unused_key_callback,
902                        field_transformer: self.field_transformer,
903                    },
904                    other => {
905                        return Err(error::set_span(
906                            Error::invalid_type(other.unexpected(), &"a Value::Tagged enum"),
907                            span,
908                        ));
909                    }
910                })
911                .map_err(|e| error::set_span(e, span))
912        )
913    }
914
915    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Error>
916    where
917        V: Visitor<'de>,
918    {
919        self.deserialize_string(visitor)
920    }
921
922    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Error>
923    where
924        V: Visitor<'de>,
925    {
926        let span = self.value.span().clone();
927        self.value.broadcast_end_mark();
928        maybe_why_not!(
929            self.value,
930            visitor.visit_unit().map_err(|e| error::set_span(e, span))
931        )
932    }
933}
934
935struct EnumRefDeserializer<'de, 'p, 'u, 'f> {
936    tag: &'de str,
937    path: Path<'p>,
938    value: Option<&'de Value>,
939    unused_key_callback: Option<UnusedKeyCallback<'u>>,
940    field_transformer: Option<FieldTransformer<'f>>,
941}
942
943impl<'de, 'p, 'u, 'f> EnumAccess<'de> for EnumRefDeserializer<'de, 'p, 'u, 'f> {
944    type Error = Error;
945    type Variant = VariantRefDeserializer<'de, 'p, 'u, 'f>;
946
947    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Error>
948    where
949        V: DeserializeSeed<'de>,
950    {
951        let str_de = BorrowedStrDeserializer::<Error>::new(self.tag);
952        let variant = seed.deserialize(str_de)?;
953        let visitor = VariantRefDeserializer {
954            value: self.value,
955            path: self.path,
956            unused_key_callback: self.unused_key_callback,
957            field_transformer: self.field_transformer,
958        };
959        Ok((variant, visitor))
960    }
961}
962
963struct VariantRefDeserializer<'de, 'p, 'u, 'f> {
964    value: Option<&'de Value>,
965    path: Path<'p>,
966    unused_key_callback: Option<UnusedKeyCallback<'u>>,
967    field_transformer: Option<FieldTransformer<'f>>,
968}
969
970impl<'de> VariantAccess<'de> for VariantRefDeserializer<'de, '_, '_, '_> {
971    type Error = Error;
972
973    fn unit_variant(self) -> Result<(), Error> {
974        match self.value {
975            Some(value) => value.unit_variant(),
976            None => Ok(()),
977        }
978    }
979
980    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Error>
981    where
982        T: DeserializeSeed<'de>,
983    {
984        match self.value {
985            Some(value) => seed.deserialize(ValueRefDeserializer::new_with(
986                value,
987                self.path,
988                self.unused_key_callback,
989                self.field_transformer,
990            )),
991            None => Err(Error::invalid_type(
992                Unexpected::UnitVariant,
993                &"newtype variant",
994            )),
995        }
996    }
997
998    fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Error>
999    where
1000        V: Visitor<'de>,
1001    {
1002        match self.value {
1003            Some(Value::Sequence(v, ..)) => Deserializer::deserialize_any(
1004                SeqRefDeserializer::new_with(
1005                    v,
1006                    self.path,
1007                    self.unused_key_callback,
1008                    self.field_transformer,
1009                ),
1010                visitor,
1011            ),
1012            Some(value) => Err(Error::invalid_type(value.unexpected(), &"tuple variant")),
1013            _ => Err(Error::invalid_type(
1014                Unexpected::UnitVariant,
1015                &"tuple variant",
1016            )),
1017        }
1018    }
1019
1020    fn struct_variant<V>(
1021        self,
1022        fields: &'static [&'static str],
1023        visitor: V,
1024    ) -> Result<V::Value, Error>
1025    where
1026        V: Visitor<'de>,
1027    {
1028        match self.value {
1029            Some(Value::Mapping(v, ..)) => Deserializer::deserialize_any(
1030                StructRefDeserializer::new_with(
1031                    v,
1032                    self.path,
1033                    fields,
1034                    self.unused_key_callback,
1035                    self.field_transformer,
1036                ),
1037                visitor,
1038            ),
1039            Some(value) => Err(Error::invalid_type(value.unexpected(), &"struct variant")),
1040            None => Err(Error::invalid_type(
1041                Unexpected::UnitVariant,
1042                &"struct variant",
1043            )),
1044        }
1045    }
1046}
1047
1048impl<'de> VariantAccess<'de> for ValueRefDeserializer<'de, '_, '_, '_> {
1049    type Error = Error;
1050
1051    fn unit_variant(self) -> Result<(), Error> {
1052        Deserialize::deserialize(self)
1053    }
1054
1055    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Error>
1056    where
1057        T: DeserializeSeed<'de>,
1058    {
1059        seed.deserialize(self)
1060    }
1061
1062    fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Error>
1063    where
1064        V: Visitor<'de>,
1065    {
1066        if let Value::Sequence(v, ..) = self.value {
1067            Deserializer::deserialize_any(
1068                SeqRefDeserializer::new_with(
1069                    v,
1070                    self.path,
1071                    self.unused_key_callback,
1072                    self.field_transformer,
1073                ),
1074                visitor,
1075            )
1076        } else {
1077            Err(Error::invalid_type(
1078                self.value.unexpected(),
1079                &"tuple variant",
1080            ))
1081        }
1082    }
1083
1084    fn struct_variant<V>(
1085        self,
1086        fields: &'static [&'static str],
1087        visitor: V,
1088    ) -> Result<V::Value, Error>
1089    where
1090        V: Visitor<'de>,
1091    {
1092        if let Value::Mapping(v, ..) = self.value {
1093            Deserializer::deserialize_any(
1094                StructRefDeserializer::new_with(
1095                    v,
1096                    self.path,
1097                    fields,
1098                    self.unused_key_callback,
1099                    self.field_transformer,
1100                ),
1101                visitor,
1102            )
1103        } else {
1104            Err(Error::invalid_type(
1105                self.value.unexpected(),
1106                &"struct variant",
1107            ))
1108        }
1109    }
1110}
1111
1112pub(crate) struct SeqRefDeserializer<'de, 'p, 'u, 'f> {
1113    iter: slice::Iter<'de, Value>,
1114    path: Path<'p>,
1115    current_idx: usize,
1116    unused_key_callback: Option<UnusedKeyCallback<'u>>,
1117    field_transformer: Option<FieldTransformer<'f>>,
1118}
1119
1120impl<'de> SeqRefDeserializer<'de, '_, '_, '_> {
1121    pub(crate) fn new(slice: &'de [Value]) -> Self {
1122        SeqRefDeserializer {
1123            iter: slice.iter(),
1124            path: Path::Root,
1125            current_idx: 0,
1126            unused_key_callback: None,
1127            field_transformer: None,
1128        }
1129    }
1130}
1131
1132impl<'de, 'p, 'u, 'f> SeqRefDeserializer<'de, 'p, 'u, 'f> {
1133    pub(crate) fn new_with(
1134        slice: &'de [Value],
1135        current_path: Path<'p>,
1136        unused_key_callback: Option<UnusedKeyCallback<'u>>,
1137        field_transformer: Option<FieldTransformer<'f>>,
1138    ) -> Self {
1139        SeqRefDeserializer {
1140            iter: slice.iter(),
1141            path: current_path,
1142            current_idx: 0,
1143            unused_key_callback,
1144            field_transformer,
1145        }
1146    }
1147}
1148
1149impl<'de> Deserializer<'de> for SeqRefDeserializer<'de, '_, '_, '_> {
1150    type Error = Error;
1151
1152    #[inline]
1153    fn deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Error>
1154    where
1155        V: Visitor<'de>,
1156    {
1157        reset_is_deserializing_value();
1158
1159        let len = self.iter.len();
1160        if len == 0 {
1161            visitor.visit_unit()
1162        } else {
1163            let ret = visitor.visit_seq(&mut self)?;
1164            let remaining = self.iter.len();
1165            if remaining == 0 {
1166                Ok(ret)
1167            } else {
1168                Err(Error::invalid_length(len, &"fewer elements in sequence"))
1169            }
1170        }
1171    }
1172
1173    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Error>
1174    where
1175        V: Visitor<'de>,
1176    {
1177        visitor.visit_unit()
1178    }
1179
1180    forward_to_deserialize_any! {
1181        bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes
1182        byte_buf option unit unit_struct newtype_struct seq tuple tuple_struct
1183        map struct enum identifier
1184    }
1185}
1186
1187impl<'de> SeqAccess<'de> for SeqRefDeserializer<'de, '_, '_, '_> {
1188    type Error = Error;
1189
1190    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error>
1191    where
1192        T: DeserializeSeed<'de>,
1193    {
1194        self.current_idx += 1;
1195        match self.iter.next() {
1196            Some(value) => {
1197                let span = value.span().clone();
1198                let deserializer = ValueRefDeserializer::new_with(
1199                    value,
1200                    Path::Seq {
1201                        parent: &self.path,
1202                        index: self.current_idx - 1,
1203                    },
1204                    self.unused_key_callback
1205                        .as_deref_mut()
1206                        .map(|cb| &mut *cb as UnusedKeyCallback<'_>),
1207                    self.field_transformer
1208                        .as_deref_mut()
1209                        .map(|ft| &mut *ft as FieldTransformer<'_>),
1210                );
1211                seed.deserialize(deserializer)
1212                    .map(Some)
1213                    .map_err(|e| error::set_span(e, span))
1214            }
1215            None => Ok(None),
1216        }
1217    }
1218
1219    fn size_hint(&self) -> Option<usize> {
1220        match self.iter.size_hint() {
1221            (lower, Some(upper)) if lower == upper => Some(upper),
1222            _ => None,
1223        }
1224    }
1225}
1226
1227pub(crate) struct MapRefDeserializer<'de, 'p, 'u, 'f> {
1228    iter: Option<Box<dyn Iterator<Item = (&'de Value, &'de Value)> + 'de>>,
1229    current_key: Option<String>,
1230    path: Path<'p>,
1231    value: Option<&'de Value>,
1232    unused_key_callback: Option<UnusedKeyCallback<'u>>,
1233    field_transformer: Option<FieldTransformer<'f>>,
1234}
1235
1236impl<'de> MapRefDeserializer<'de, '_, '_, '_> {
1237    pub(crate) fn new(map: &'de Mapping) -> Self {
1238        MapRefDeserializer {
1239            iter: Some(Box::new(map.iter())),
1240            current_key: None,
1241            path: Path::Root,
1242            value: None,
1243            unused_key_callback: None,
1244            field_transformer: None,
1245        }
1246    }
1247}
1248
1249impl<'de, 'p, 'u, 'f> MapRefDeserializer<'de, 'p, 'u, 'f> {
1250    pub(crate) fn new_empty(path: Path<'p>) -> Self {
1251        MapRefDeserializer {
1252            iter: None,
1253            current_key: None,
1254            path,
1255            value: None,
1256            unused_key_callback: None,
1257            field_transformer: None,
1258        }
1259    }
1260
1261    pub(crate) fn new_with(
1262        map: &'de Mapping,
1263        path: Path<'p>,
1264        unused_key_callback: Option<UnusedKeyCallback<'u>>,
1265        field_transformer: Option<FieldTransformer<'f>>,
1266    ) -> Self {
1267        MapRefDeserializer {
1268            iter: Some(Box::new(map.iter())),
1269            current_key: None,
1270            path,
1271            value: None,
1272            unused_key_callback,
1273            field_transformer,
1274        }
1275    }
1276}
1277
1278impl<'de> MapAccess<'de> for MapRefDeserializer<'de, '_, '_, '_> {
1279    type Error = Error;
1280
1281    fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error>
1282    where
1283        T: DeserializeSeed<'de>,
1284    {
1285        self.current_key = None;
1286        match self.iter.as_mut().and_then(Iterator::next) {
1287            Some((key, value)) => {
1288                self.value = Some(value);
1289                self.current_key = key.as_str().map(String::from);
1290                let deserializer = ValueRefDeserializer::new_with(key, self.path, None, None);
1291                seed.deserialize(deserializer).map(Some)
1292            }
1293            None => Ok(None),
1294        }
1295    }
1296
1297    fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Error>
1298    where
1299        T: DeserializeSeed<'de>,
1300    {
1301        match self.value.take() {
1302            Some(value) => seed.deserialize(ValueRefDeserializer::new_with(
1303                value,
1304                match self.current_key {
1305                    Some(ref key) => Path::Map {
1306                        parent: &self.path,
1307                        key,
1308                    },
1309                    None => Path::Unknown { parent: &self.path },
1310                },
1311                self.unused_key_callback
1312                    .as_deref_mut()
1313                    .map(|cb| &mut *cb as UnusedKeyCallback<'_>),
1314                self.field_transformer
1315                    .as_deref_mut()
1316                    .map(|cb| &mut *cb as FieldTransformer<'_>),
1317            )),
1318            None => panic!("visit_value called before visit_key"),
1319        }
1320    }
1321
1322    fn size_hint(&self) -> Option<usize> {
1323        match self.iter.as_ref()?.size_hint() {
1324            (lower, Some(upper)) if lower == upper => Some(upper),
1325            _ => None,
1326        }
1327    }
1328}
1329
1330impl<'de> Deserializer<'de> for MapRefDeserializer<'de, '_, '_, '_> {
1331    type Error = Error;
1332
1333    #[inline]
1334    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
1335    where
1336        V: Visitor<'de>,
1337    {
1338        if super::should_short_circuit_any(self.field_transformer.is_some()) {
1339            let value = Value::mapping(
1340                self.iter
1341                    .into_iter()
1342                    .flatten()
1343                    .map(|(key, value)| (key.clone(), value.clone()))
1344                    .collect(),
1345            );
1346            // SAFETY: self.unused_key_callback and self.field_transformer are
1347            // passed in from outside and guaranteed to be valid for 'de
1348            unsafe {
1349                save_deserializer_state(
1350                    Some(value),
1351                    self.path,
1352                    self.unused_key_callback,
1353                    self.field_transformer,
1354                );
1355            }
1356            return Err(Error::custom("Value deserialized via fast path"));
1357        }
1358
1359        visitor.visit_map(self)
1360    }
1361
1362    fn deserialize_struct<V>(
1363        self,
1364        _name: &'static str,
1365        fields: &'static [&'static str],
1366        visitor: V,
1367    ) -> Result<V::Value, Error>
1368    where
1369        V: Visitor<'de>,
1370    {
1371        let (normal_keys, flatten_keys): (Vec<_>, Vec<_>) = fields
1372            .iter()
1373            .copied()
1374            .partition(|key| !crate::is_flatten_key(key.as_bytes()));
1375        visitor.visit_map(StructRefDeserializer {
1376            iter: self.iter,
1377            current_key: None,
1378            path: self.path,
1379            value: None,
1380            normal_keys: normal_keys.into_iter().collect(),
1381            flatten_keys,
1382            unused_key_callback: self.unused_key_callback,
1383            field_transformer: self.field_transformer,
1384            rest: Vec::new(),
1385            flatten_keys_done: 0,
1386        })
1387    }
1388
1389    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Error>
1390    where
1391        V: Visitor<'de>,
1392    {
1393        visitor.visit_unit()
1394    }
1395
1396    forward_to_deserialize_any! {
1397        bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes
1398        byte_buf option unit unit_struct newtype_struct seq tuple tuple_struct
1399        map enum identifier
1400    }
1401}
1402
1403pub(crate) struct StructRefDeserializer<'de, 'p, 'u, 'f> {
1404    iter: Option<Box<dyn Iterator<Item = (&'de Value, &'de Value)> + 'de>>,
1405    current_key: Option<String>,
1406    path: Path<'p>,
1407    value: Option<&'de Value>,
1408    normal_keys: HashSet<&'static str>,
1409    flatten_keys: Vec<&'static str>,
1410    unused_key_callback: Option<UnusedKeyCallback<'u>>,
1411    field_transformer: Option<FieldTransformer<'f>>,
1412    rest: Vec<(&'de Value, &'de Value)>,
1413    flatten_keys_done: usize,
1414}
1415
1416impl<'de, 'p, 'u, 'f> StructRefDeserializer<'de, 'p, 'u, 'f> {
1417    pub(crate) fn new_with(
1418        map: &'de Mapping,
1419        current_path: Path<'p>,
1420        known_keys: &'static [&'static str],
1421        unused_key_callback: Option<UnusedKeyCallback<'u>>,
1422        field_transformer: Option<FieldTransformer<'f>>,
1423    ) -> Self {
1424        let (normal_keys, flatten_keys): (Vec<_>, Vec<_>) = known_keys
1425            .iter()
1426            .copied()
1427            .partition(|key| !crate::is_flatten_key(key.as_bytes()));
1428        StructRefDeserializer {
1429            iter: Some(Box::new(map.iter())),
1430            current_key: None,
1431            path: current_path,
1432            value: None,
1433            normal_keys: normal_keys.into_iter().collect(),
1434            flatten_keys,
1435            unused_key_callback,
1436            field_transformer,
1437            rest: Vec::new(),
1438            flatten_keys_done: 0,
1439        }
1440    }
1441
1442    pub(crate) fn has_flatten(&self) -> bool {
1443        !self.flatten_keys.is_empty()
1444    }
1445
1446    fn has_unprocessed_flatten_keys(&self) -> bool {
1447        self.flatten_keys_done < self.flatten_keys.len()
1448    }
1449}
1450
1451impl<'de> MapAccess<'de> for StructRefDeserializer<'de, '_, '_, '_> {
1452    type Error = Error;
1453
1454    fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error>
1455    where
1456        T: DeserializeSeed<'de>,
1457    {
1458        self.current_key = None;
1459        loop {
1460            match self.iter.as_mut().and_then(Iterator::next) {
1461                Some((key, value)) => {
1462                    match key.as_str() {
1463                        Some(key_str) if crate::is_flatten_key(key_str.as_bytes()) => {
1464                            self.rest.push((key, value));
1465                            continue;
1466                        }
1467                        Some(key_str) if !self.normal_keys.contains(key_str) => {
1468                            if self.has_flatten() {
1469                                self.rest.push((key, value));
1470                                continue;
1471                            } else if let Some(callback) = &mut self.unused_key_callback {
1472                                value.broadcast_end_mark();
1473                                let key_string = key_str.to_string();
1474                                let path = Path::Map {
1475                                    parent: &self.path,
1476                                    key: &key_string,
1477                                };
1478                                callback(path, key, value);
1479                                continue;
1480                            }
1481                        }
1482                        _ => {}
1483                    };
1484
1485                    self.current_key = key.as_str().map(|s| s.to_string());
1486                    self.value = Some(value);
1487                    break seed.deserialize(ValueRefDeserializer::new(key)).map(Some);
1488                }
1489                None if self.has_unprocessed_flatten_keys() => {
1490                    let key = self.flatten_keys[self.flatten_keys_done];
1491                    self.current_key = Some(key.to_string());
1492                    break seed
1493                        .deserialize(super::ValueDeserializer::new(key.into()))
1494                        .map(Some);
1495                }
1496                None => break Ok(None),
1497            }
1498        }
1499    }
1500
1501    fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Error>
1502    where
1503        T: DeserializeSeed<'de>,
1504    {
1505        match self.value.take() {
1506            Some(value) => seed.deserialize(ValueRefDeserializer::new_with(
1507                value,
1508                match self.current_key {
1509                    Some(ref key) => Path::Map {
1510                        parent: &self.path,
1511                        key,
1512                    },
1513                    None => Path::Unknown { parent: &self.path },
1514                },
1515                self.unused_key_callback
1516                    .as_deref_mut()
1517                    .map(|cb| &mut *cb as UnusedKeyCallback<'_>),
1518                self.field_transformer
1519                    .as_deref_mut()
1520                    .map(|cb| &mut *cb as FieldTransformer<'_>),
1521            )),
1522            None if self.has_unprocessed_flatten_keys() => {
1523                self.flatten_keys_done += 1;
1524
1525                let flattened = self.rest.drain(..).collect::<Vec<_>>();
1526                let path = match self.current_key {
1527                    Some(ref key) => Path::Map {
1528                        parent: &self.path,
1529                        key,
1530                    },
1531                    None => Path::Unknown { parent: &self.path },
1532                };
1533
1534                if self.has_unprocessed_flatten_keys() {
1535                    let deserializer = FlattenRefDeserializer::new(
1536                        Some(Box::new(flattened.into_iter())),
1537                        path,
1538                        &mut self.rest,
1539                        self.field_transformer
1540                            .as_deref_mut()
1541                            .map(|cb| &mut *cb as FieldTransformer<'_>),
1542                    );
1543
1544                    seed.deserialize(deserializer)
1545                } else {
1546                    let deserializer = MapRefDeserializer {
1547                        iter: Some(Box::new(flattened.into_iter())),
1548                        current_key: None,
1549                        path,
1550                        value: None,
1551                        unused_key_callback: self
1552                            .unused_key_callback
1553                            .as_deref_mut()
1554                            .map(|cb| &mut *cb as UnusedKeyCallback<'_>),
1555                        field_transformer: self
1556                            .field_transformer
1557                            .as_deref_mut()
1558                            .map(|cb| &mut *cb as FieldTransformer<'_>),
1559                    };
1560                    seed.deserialize(deserializer)
1561                }
1562            }
1563            None => panic!("visit_value called before visit_key"),
1564        }
1565    }
1566
1567    fn size_hint(&self) -> Option<usize> {
1568        match self.iter.as_ref()?.size_hint() {
1569            (lower, Some(upper)) if lower == upper => Some(upper),
1570            _ => None,
1571        }
1572    }
1573}
1574
1575impl<'de> Deserializer<'de> for StructRefDeserializer<'de, '_, '_, '_> {
1576    type Error = Error;
1577
1578    #[inline]
1579    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
1580    where
1581        V: Visitor<'de>,
1582    {
1583        reset_is_deserializing_value();
1584        visitor.visit_map(self)
1585    }
1586
1587    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Error>
1588    where
1589        V: Visitor<'de>,
1590    {
1591        drop(self);
1592        visitor.visit_unit()
1593    }
1594
1595    forward_to_deserialize_any! {
1596        bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes
1597        byte_buf option unit unit_struct newtype_struct seq tuple tuple_struct
1598        map struct enum identifier
1599    }
1600}
1601
1602struct FlattenRefDeserializer<'de, 'p, 'r, 'f> {
1603    iter: Option<Box<dyn Iterator<Item = (&'de Value, &'de Value)> + 'de>>,
1604    path: Path<'p>,
1605    remaining: &'r mut Vec<(&'de Value, &'de Value)>,
1606    field_transformer: Option<FieldTransformer<'f>>,
1607}
1608
1609impl<'de, 'p, 'r, 'f> FlattenRefDeserializer<'de, 'p, 'r, 'f> {
1610    pub(crate) fn new(
1611        iter: Option<Box<dyn Iterator<Item = (&'de Value, &'de Value)> + 'de>>,
1612        current_path: Path<'p>,
1613        remaining: &'r mut Vec<(&'de Value, &'de Value)>,
1614        field_transformer: Option<FieldTransformer<'f>>,
1615    ) -> Self {
1616        FlattenRefDeserializer {
1617            iter,
1618            path: current_path,
1619            remaining,
1620            field_transformer,
1621        }
1622    }
1623}
1624
1625impl<'de> Deserializer<'de> for FlattenRefDeserializer<'de, '_, '_, '_> {
1626    type Error = Error;
1627
1628    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
1629    where
1630        V: Visitor<'de>,
1631    {
1632        let mut collect_unused = move |_: Path<'_>, key: &Value, value: &Value| {
1633            // SAFETY: the references passed to this closure are
1634            // guaranteed to be borrowed for 'de
1635            let key: &'de Value = unsafe { std::mem::transmute(key) };
1636            let value: &'de Value = unsafe { std::mem::transmute(value) };
1637            self.remaining.push((key, value));
1638        };
1639
1640        if super::should_short_circuit_any(self.field_transformer.is_some()) {
1641            let value = Value::mapping(
1642                self.iter
1643                    .into_iter()
1644                    .flatten()
1645                    .map(|(key, value)| (key.clone(), value.clone()))
1646                    .collect(),
1647            );
1648            unsafe {
1649                save_deserializer_state(
1650                    Some(value),
1651                    self.path,
1652                    // FIXME: we can't propagate the collect_unused callback
1653                    // because it's internally unsafe:
1654                    None,
1655                    self.field_transformer,
1656                );
1657            }
1658            return Err(Error::custom("Value deserialized via fast path"));
1659        }
1660
1661        let deserializer = MapRefDeserializer {
1662            iter: self.iter,
1663            current_key: None,
1664            path: self.path,
1665            value: None,
1666            unused_key_callback: Some(&mut collect_unused),
1667            field_transformer: self.field_transformer,
1668        };
1669        visitor.visit_map(deserializer)
1670    }
1671
1672    fn deserialize_struct<V>(
1673        self,
1674        _name: &'static str,
1675        fields: &'static [&'static str],
1676        visitor: V,
1677    ) -> Result<V::Value, Error>
1678    where
1679        V: Visitor<'de>,
1680    {
1681        let mut collect_unused = |_: Path<'_>, key: &Value, value: &Value| {
1682            // SAFETY: the references passed to this closure are
1683            // guaranteed to be borrowed for 'de
1684            let key: &'de Value = unsafe { std::mem::transmute(key) };
1685            let value: &'de Value = unsafe { std::mem::transmute(value) };
1686            self.remaining.push((key, value));
1687        };
1688
1689        let (normal_keys, flatten_keys): (Vec<_>, Vec<_>) = fields
1690            .iter()
1691            .copied()
1692            .partition(|key| !crate::is_flatten_key(key.as_bytes()));
1693        let deserializer = StructRefDeserializer {
1694            iter: self.iter,
1695            current_key: None,
1696            path: self.path,
1697            value: None,
1698            normal_keys: normal_keys.into_iter().collect(),
1699            flatten_keys,
1700            unused_key_callback: Some(&mut collect_unused),
1701            field_transformer: self.field_transformer,
1702            rest: Vec::new(),
1703            flatten_keys_done: 0,
1704        };
1705        visitor.visit_map(deserializer)
1706    }
1707
1708    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Error>
1709    where
1710        V: Visitor<'de>,
1711    {
1712        drop(self);
1713        visitor.visit_unit()
1714    }
1715
1716    forward_to_deserialize_any! {
1717        bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes
1718        byte_buf option unit unit_struct newtype_struct seq tuple tuple_struct
1719        map enum identifier
1720    }
1721}
dbt_yaml/value/de/borrowed.rs

dbt_yaml/value/de/
borrowed.rs
