dbt_yaml/value/de/
owned.rs

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

dbt_yaml/value/de/
owned.rs
