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, self.path))
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, self.path))
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, self.path))
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, self.path))
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, self.path))
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, self.path))
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        let path = self.path;
718        self.value.broadcast_end_mark();
719        visitor
720            .visit_newtype_struct(self)
721            .map_err(|e| error::set_span(e, span, path))
722    }
723
724    fn deserialize_seq<V>(mut self, visitor: V) -> Result<V::Value, Error>
725    where
726        V: Visitor<'de>,
727    {
728        maybe_expecting_should_be!(self, deserialize_seq, visitor);
729        self.maybe_apply_transformation()?;
730
731        let span = self.value.span().clone();
732        self.value.broadcast_end_mark();
733        match self.value.untag() {
734            Value::Sequence(v, ..) => visit_sequence(
735                v,
736                self.path,
737                visitor,
738                self.unused_key_callback,
739                self.field_transformer,
740            ),
741            Value::Null(..) => visit_sequence(
742                Sequence::new(),
743                self.path,
744                visitor,
745                self.unused_key_callback,
746                self.field_transformer,
747            ),
748            other => Err(other.invalid_type(&visitor)),
749        }
750        .map_err(|e| error::set_span(e, span, self.path))
751    }
752
753    fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Error>
754    where
755        V: Visitor<'de>,
756    {
757        self.deserialize_seq(visitor)
758    }
759
760    fn deserialize_tuple_struct<V>(
761        self,
762        _name: &'static str,
763        _len: usize,
764        visitor: V,
765    ) -> Result<V::Value, Error>
766    where
767        V: Visitor<'de>,
768    {
769        self.deserialize_seq(visitor)
770    }
771
772    fn deserialize_map<V>(mut self, visitor: V) -> Result<V::Value, Error>
773    where
774        V: Visitor<'de>,
775    {
776        maybe_expecting_should_be!(self, deserialize_map, visitor);
777        self.maybe_apply_transformation()?;
778
779        let span = self.value.span().clone();
780        self.value.broadcast_end_mark();
781        match self.value.untag() {
782            Value::Mapping(v, ..) => visit_mapping(
783                v,
784                self.path,
785                visitor,
786                self.unused_key_callback,
787                self.field_transformer,
788            ),
789            Value::Null(..) => visit_mapping(
790                Mapping::new(),
791                self.path,
792                visitor,
793                self.unused_key_callback,
794                self.field_transformer,
795            ),
796            other => Err(other.invalid_type(&visitor)),
797        }
798        .map_err(|e| error::set_span(e, span, self.path))
799    }
800
801    fn deserialize_struct<V>(
802        mut self,
803        name: &'static str,
804        fields: &'static [&'static str],
805        visitor: V,
806    ) -> Result<V::Value, Error>
807    where
808        V: Visitor<'de>,
809    {
810        maybe_expecting_should_be!(self, deserialize_struct, name, fields, visitor);
811        self.maybe_apply_transformation()?;
812
813        let span = self.value.span().clone();
814        self.value.broadcast_end_mark();
815        match self.value.untag() {
816            Value::Mapping(v, ..) => visit_struct(
817                v,
818                self.path,
819                visitor,
820                fields,
821                self.unused_key_callback,
822                self.field_transformer,
823            ),
824            Value::Null(..) => visit_struct(
825                Mapping::new(),
826                self.path,
827                visitor,
828                fields,
829                self.unused_key_callback,
830                self.field_transformer,
831            ),
832            other => Err(other.invalid_type(&visitor)),
833        }
834        .map_err(|e| error::set_span(e, span, self.path))
835    }
836
837    fn deserialize_enum<V>(
838        mut self,
839        name: &'static str,
840        variants: &'static [&'static str],
841        visitor: V,
842    ) -> Result<V::Value, Error>
843    where
844        V: Visitor<'de>,
845    {
846        maybe_expecting_should_be!(self, deserialize_enum, name, variants, visitor);
847        self.maybe_apply_transformation()?;
848
849        let span = self.value.span().clone();
850        self.value.broadcast_end_mark();
851
852        let tag;
853        visitor
854            .visit_enum(match self.value {
855                Value::Tagged(tagged, ..) => EnumDeserializer {
856                    tag: {
857                        tag = tagged.tag.string;
858                        tagged::nobang(&tag)
859                    },
860                    path: self.path,
861                    value: Some(tagged.value),
862                    unused_key_callback: self.unused_key_callback,
863                    field_transformer: self.field_transformer,
864                },
865                Value::String(variant, ..) => EnumDeserializer {
866                    tag: {
867                        tag = variant;
868                        &tag
869                    },
870                    path: self.path,
871                    value: None,
872                    unused_key_callback: self.unused_key_callback,
873                    field_transformer: self.field_transformer,
874                },
875                other => {
876                    return Err(Error::invalid_type(
877                        other.unexpected(),
878                        &"a Value::Tagged enum",
879                    ));
880                }
881            })
882            .map_err(|e| error::set_span(e, span, self.path))
883    }
884
885    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Error>
886    where
887        V: Visitor<'de>,
888    {
889        self.deserialize_string(visitor)
890    }
891
892    fn deserialize_ignored_any<V>(mut self, visitor: V) -> Result<V::Value, Error>
893    where
894        V: Visitor<'de>,
895    {
896        maybe_expecting_should_be!(self, deserialize_ignored_any, visitor);
897
898        let span = self.value.span().clone();
899        let path = self.path;
900        self.value.broadcast_end_mark();
901        drop(self);
902        visitor
903            .visit_unit()
904            .map_err(|e| error::set_span(e, span, path))
905    }
906}
907
908struct EnumDeserializer<'a, 'u, 'f> {
909    tag: &'a str,
910    path: Path<'a>,
911    value: Option<Value>,
912    unused_key_callback: Option<UnusedKeyCallback<'u>>,
913    field_transformer: Option<FieldTransformer<'f>>,
914}
915
916impl<'de, 'a, 'u, 'f> EnumAccess<'de> for EnumDeserializer<'a, 'u, 'f> {
917    type Error = Error;
918    type Variant = VariantDeserializer<'a, 'u, 'f>;
919
920    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Error>
921    where
922        V: DeserializeSeed<'de>,
923    {
924        let str_de = StrDeserializer::<Error>::new(self.tag);
925        let variant = seed.deserialize(str_de)?;
926        let visitor = VariantDeserializer {
927            value: self.value,
928            path: self.path,
929            unused_key_callback: self.unused_key_callback,
930            field_transformer: self.field_transformer,
931        };
932        Ok((variant, visitor))
933    }
934}
935
936struct VariantDeserializer<'a, 'u, 'f> {
937    value: Option<Value>,
938    path: Path<'a>,
939    unused_key_callback: Option<UnusedKeyCallback<'u>>,
940    field_transformer: Option<FieldTransformer<'f>>,
941}
942
943impl<'de, 'u, 'f> VariantAccess<'de> for VariantDeserializer<'_, 'f, 'u> {
944    type Error = Error;
945
946    fn unit_variant(self) -> Result<(), Error> {
947        match self.value {
948            Some(value) => value.unit_variant(),
949            None => Ok(()),
950        }
951    }
952
953    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Error>
954    where
955        T: DeserializeSeed<'de>,
956    {
957        match self.value {
958            Some(value) => seed.deserialize(ValueDeserializer::new_with(
959                value,
960                self.path,
961                self.unused_key_callback,
962                self.field_transformer,
963            )),
964            None => Err(Error::invalid_type(
965                Unexpected::UnitVariant,
966                &"newtype variant",
967            )),
968        }
969    }
970
971    fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Error>
972    where
973        V: Visitor<'de>,
974    {
975        match self.value {
976            Some(Value::Sequence(v, ..)) => Deserializer::deserialize_any(
977                SeqDeserializer::new(
978                    v,
979                    self.path,
980                    self.unused_key_callback,
981                    self.field_transformer,
982                ),
983                visitor,
984            ),
985            Some(value) => Err(Error::invalid_type(value.unexpected(), &"tuple variant")),
986            _ => Err(Error::invalid_type(
987                Unexpected::UnitVariant,
988                &"tuple variant",
989            )),
990        }
991    }
992
993    fn struct_variant<V>(
994        self,
995        fields: &'static [&'static str],
996        visitor: V,
997    ) -> Result<V::Value, Error>
998    where
999        V: Visitor<'de>,
1000    {
1001        match self.value {
1002            Some(Value::Mapping(v, ..)) => Deserializer::deserialize_any(
1003                StructDeserializer::new(
1004                    v,
1005                    self.path,
1006                    fields,
1007                    self.unused_key_callback,
1008                    self.field_transformer,
1009                ),
1010                visitor,
1011            ),
1012            Some(value) => Err(Error::invalid_type(value.unexpected(), &"struct variant")),
1013            _ => Err(Error::invalid_type(
1014                Unexpected::UnitVariant,
1015                &"struct variant",
1016            )),
1017        }
1018    }
1019}
1020
1021impl<'de, 'u, 'f> VariantAccess<'de> for ValueDeserializer<'_, 'u, 'f> {
1022    type Error = Error;
1023
1024    fn unit_variant(self) -> Result<(), Error> {
1025        Deserialize::deserialize(self)
1026    }
1027
1028    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Error>
1029    where
1030        T: DeserializeSeed<'de>,
1031    {
1032        seed.deserialize(self)
1033    }
1034
1035    fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Error>
1036    where
1037        V: Visitor<'de>,
1038    {
1039        if let Value::Sequence(v, ..) = self.value {
1040            Deserializer::deserialize_any(
1041                SeqDeserializer::new(
1042                    v,
1043                    self.path,
1044                    self.unused_key_callback,
1045                    self.field_transformer,
1046                ),
1047                visitor,
1048            )
1049        } else {
1050            Err(Error::invalid_type(
1051                self.value.unexpected(),
1052                &"tuple variant",
1053            ))
1054        }
1055    }
1056
1057    fn struct_variant<V>(
1058        self,
1059        fields: &'static [&'static str],
1060        visitor: V,
1061    ) -> Result<V::Value, Error>
1062    where
1063        V: Visitor<'de>,
1064    {
1065        if let Value::Mapping(v, ..) = self.value {
1066            Deserializer::deserialize_any(
1067                StructDeserializer::new(
1068                    v,
1069                    self.path,
1070                    fields,
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                &"struct variant",
1080            ))
1081        }
1082    }
1083}
1084
1085pub(crate) struct SeqDeserializer<'a, 'u, 'f> {
1086    iter: vec::IntoIter<Value>,
1087    current_idx: usize,
1088    path: Path<'a>,
1089    unused_key_callback: Option<UnusedKeyCallback<'u>>,
1090    field_transformer: Option<FieldTransformer<'f>>,
1091}
1092
1093impl<'a, 'u, 'f> SeqDeserializer<'a, 'u, 'f> {
1094    pub(crate) fn new(
1095        vec: Vec<Value>,
1096        current_path: Path<'a>,
1097        unused_key_callback: Option<UnusedKeyCallback<'u>>,
1098        field_transformer: Option<FieldTransformer<'f>>,
1099    ) -> Self {
1100        SeqDeserializer {
1101            iter: vec.into_iter(),
1102            current_idx: 0,
1103            path: current_path,
1104            unused_key_callback,
1105            field_transformer,
1106        }
1107    }
1108}
1109
1110impl<'de, 'u, 'f> Deserializer<'de> for SeqDeserializer<'_, 'u, 'f> {
1111    type Error = Error;
1112
1113    #[inline]
1114    fn deserialize_any<V>(mut self, visitor: V) -> Result<V::Value, Error>
1115    where
1116        V: Visitor<'de>,
1117    {
1118        reset_is_deserializing_value();
1119        let len = self.iter.len();
1120        if len == 0 {
1121            visitor.visit_unit()
1122        } else {
1123            let ret = visitor.visit_seq(&mut self)?;
1124            let remaining = self.iter.len();
1125            if remaining == 0 {
1126                Ok(ret)
1127            } else {
1128                Err(Error::invalid_length(len, &"fewer elements in sequence"))
1129            }
1130        }
1131    }
1132
1133    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Error>
1134    where
1135        V: Visitor<'de>,
1136    {
1137        drop(self);
1138        visitor.visit_unit()
1139    }
1140
1141    forward_to_deserialize_any! {
1142        bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes
1143        byte_buf option unit unit_struct newtype_struct seq tuple tuple_struct
1144        map struct enum identifier
1145    }
1146}
1147
1148impl<'de, 'u, 'f> SeqAccess<'de> for SeqDeserializer<'_, 'u, 'f> {
1149    type Error = Error;
1150
1151    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error>
1152    where
1153        T: DeserializeSeed<'de>,
1154    {
1155        self.current_idx += 1;
1156        match self.iter.next() {
1157            Some(value) => {
1158                let span = value.span().clone();
1159                let unused_key_callback = self
1160                    .unused_key_callback
1161                    .as_deref_mut()
1162                    .map(|cb| &mut *cb as UnusedKeyCallback<'_>);
1163                let field_transformer = self
1164                    .field_transformer
1165                    .as_deref_mut()
1166                    .map(|cb| &mut *cb as FieldTransformer<'_>);
1167                let deserializer = ValueDeserializer::new_with(
1168                    value,
1169                    Path::Seq {
1170                        parent: &self.path,
1171                        index: self.current_idx - 1,
1172                    },
1173                    unused_key_callback,
1174                    field_transformer,
1175                );
1176                seed.deserialize(deserializer)
1177                    .map(Some)
1178                    .map_err(|e| error::set_span(e, span, self.path))
1179            }
1180            None => Ok(None),
1181        }
1182    }
1183
1184    fn size_hint(&self) -> Option<usize> {
1185        match self.iter.size_hint() {
1186            (lower, Some(upper)) if lower == upper => Some(upper),
1187            _ => None,
1188        }
1189    }
1190}
1191
1192pub(crate) struct MapDeserializer<'a, 'u, 'f> {
1193    iter: <Mapping as IntoIterator>::IntoIter,
1194    current_key: Option<String>,
1195    path: Path<'a>,
1196    value: Option<Value>,
1197    unused_key_callback: Option<UnusedKeyCallback<'u>>,
1198    field_transformer: Option<FieldTransformer<'f>>,
1199}
1200
1201impl<'a, 'u, 'f> MapDeserializer<'a, 'u, 'f> {
1202    pub(crate) fn new(
1203        map: Mapping,
1204        current_path: Path<'a>,
1205        unused_key_callback: Option<UnusedKeyCallback<'u>>,
1206        field_transformer: Option<FieldTransformer<'f>>,
1207    ) -> Self {
1208        MapDeserializer {
1209            iter: map.into_iter(),
1210            current_key: None,
1211            path: current_path,
1212            value: None,
1213            unused_key_callback,
1214            field_transformer,
1215        }
1216    }
1217}
1218
1219impl<'de, 'u, 'f> MapAccess<'de> for MapDeserializer<'_, 'u, 'f> {
1220    type Error = Error;
1221
1222    fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error>
1223    where
1224        T: DeserializeSeed<'de>,
1225    {
1226        self.current_key = None;
1227        match self.iter.next() {
1228            Some((key, value)) => {
1229                self.value = Some(value);
1230                self.current_key = key.as_str().map(|s| s.to_string());
1231                let deserializer = ValueDeserializer::new_with(key, self.path, None, None);
1232                seed.deserialize(deserializer).map(Some)
1233            }
1234            None => Ok(None),
1235        }
1236    }
1237
1238    fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Error>
1239    where
1240        T: DeserializeSeed<'de>,
1241    {
1242        match self.value.take() {
1243            Some(value) => seed.deserialize(ValueDeserializer::new_with(
1244                value,
1245                match self.current_key {
1246                    Some(ref key) if !crate::is_flatten_key(key.as_bytes()) => Path::Map {
1247                        parent: &self.path,
1248                        key,
1249                    },
1250                    Some(_) => self.path,
1251                    None => Path::Unknown { parent: &self.path },
1252                },
1253                self.unused_key_callback
1254                    .as_deref_mut()
1255                    .map(|cb| &mut *cb as UnusedKeyCallback<'_>),
1256                self.field_transformer
1257                    .as_deref_mut()
1258                    .map(|cb| &mut *cb as FieldTransformer<'_>),
1259            )),
1260            None => panic!("visit_value called before visit_key"),
1261        }
1262    }
1263
1264    fn size_hint(&self) -> Option<usize> {
1265        match self.iter.size_hint() {
1266            (lower, Some(upper)) if lower == upper => Some(upper),
1267            _ => None,
1268        }
1269    }
1270}
1271
1272impl<'de, 'u, 'f> Deserializer<'de> for MapDeserializer<'_, 'u, 'f> {
1273    type Error = Error;
1274
1275    #[inline]
1276    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
1277    where
1278        V: Visitor<'de>,
1279    {
1280        if super::should_short_circuit_any(self.field_transformer.is_some()) {
1281            let value = Value::mapping(self.iter.collect());
1282            // SAFETY: self.unused_key_callback and self.field_transformer are
1283            // passed in from outside and guaranteed to be valid for 'de
1284            unsafe {
1285                save_deserializer_state(
1286                    Some(value),
1287                    self.path,
1288                    self.unused_key_callback,
1289                    self.field_transformer,
1290                );
1291            }
1292            return Err(Error::custom("Value deserialized via fast path"));
1293        }
1294
1295        visitor.visit_map(self)
1296    }
1297
1298    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Error>
1299    where
1300        V: Visitor<'de>,
1301    {
1302        drop(self);
1303        visitor.visit_unit()
1304    }
1305
1306    forward_to_deserialize_any! {
1307        bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes
1308        byte_buf option unit unit_struct newtype_struct seq tuple tuple_struct
1309        map struct enum identifier
1310    }
1311}
1312
1313pub(crate) struct StructDeserializer<'a, 'u, 'f> {
1314    iter: <Mapping as IntoIterator>::IntoIter,
1315    current_key: Option<String>,
1316    path: Path<'a>,
1317    value: Option<Value>,
1318    normal_keys: HashSet<&'static str>,
1319    flatten_keys: Vec<&'static str>,
1320    unused_key_callback: Option<UnusedKeyCallback<'u>>,
1321    field_transformer: Option<FieldTransformer<'f>>,
1322    rest: Vec<(Value, Value)>,
1323    flatten_keys_done: usize,
1324}
1325
1326impl<'a, 'u, 'f> StructDeserializer<'a, 'u, 'f> {
1327    pub(crate) fn new(
1328        map: Mapping,
1329        current_path: Path<'a>,
1330        known_keys: &'static [&'static str],
1331        unused_key_callback: Option<UnusedKeyCallback<'u>>,
1332        field_transformer: Option<FieldTransformer<'f>>,
1333    ) -> Self {
1334        let (normal_keys, flatten_keys): (Vec<_>, Vec<_>) = known_keys
1335            .iter()
1336            .copied()
1337            .partition(|key| !crate::is_flatten_key(key.as_bytes()));
1338        StructDeserializer {
1339            iter: map.into_iter(),
1340            current_key: None,
1341            path: current_path,
1342            value: None,
1343            normal_keys: normal_keys.into_iter().collect(),
1344            flatten_keys,
1345            unused_key_callback,
1346            field_transformer,
1347            rest: Vec::new(),
1348            flatten_keys_done: 0,
1349        }
1350    }
1351
1352    pub(crate) fn has_flatten(&self) -> bool {
1353        !self.flatten_keys.is_empty()
1354    }
1355
1356    fn has_unprocessed_flatten_keys(&self) -> bool {
1357        self.flatten_keys_done < self.flatten_keys.len()
1358    }
1359}
1360
1361impl<'de> MapAccess<'de> for StructDeserializer<'_, '_, '_> {
1362    type Error = Error;
1363
1364    fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error>
1365    where
1366        T: DeserializeSeed<'de>,
1367    {
1368        self.current_key = None;
1369        loop {
1370            match self.iter.next() {
1371                Some((key, value)) => {
1372                    match key.as_str() {
1373                        Some(key_str) if crate::is_flatten_key(key_str.as_bytes()) => {
1374                            self.rest.push((key, value));
1375                            continue;
1376                        }
1377                        Some(key_str) if !self.normal_keys.contains(key_str) => {
1378                            if self.has_flatten() {
1379                                self.rest.push((key, value));
1380                                continue;
1381                            } else if let Some(callback) = &mut self.unused_key_callback {
1382                                value.broadcast_end_mark();
1383                                let key_string = key_str.to_string();
1384                                let path = Path::Map {
1385                                    parent: &self.path,
1386                                    key: &key_string,
1387                                };
1388                                callback(path, &key, &value);
1389                                continue;
1390                            }
1391                        }
1392                        _ => {}
1393                    };
1394
1395                    self.current_key = key.as_str().map(|s| s.to_string());
1396                    self.value = Some(value);
1397                    break seed.deserialize(ValueDeserializer::new(key)).map(Some);
1398                }
1399                None if self.has_unprocessed_flatten_keys() => {
1400                    let key = self.flatten_keys[self.flatten_keys_done];
1401                    self.current_key = Some(key.to_string());
1402                    break seed
1403                        .deserialize(ValueDeserializer::new(key.into()))
1404                        .map(Some);
1405                }
1406                None => break Ok(None),
1407            }
1408        }
1409    }
1410
1411    fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Error>
1412    where
1413        T: DeserializeSeed<'de>,
1414    {
1415        match self.value.take() {
1416            Some(value) => seed.deserialize(ValueDeserializer::new_with(
1417                value,
1418                match self.current_key {
1419                    Some(ref key) => Path::Map {
1420                        parent: &self.path,
1421                        key,
1422                    },
1423                    None => Path::Unknown { parent: &self.path },
1424                },
1425                self.unused_key_callback
1426                    .as_deref_mut()
1427                    .map(|cb| &mut *cb as UnusedKeyCallback<'_>),
1428                self.field_transformer
1429                    .as_deref_mut()
1430                    .map(|cb| &mut *cb as FieldTransformer<'_>),
1431            )),
1432            None if self.has_unprocessed_flatten_keys() => {
1433                self.flatten_keys_done += 1;
1434
1435                // Flatten keys are always dunder-wrapped; do not add them to the path.
1436                let path = self.path;
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
