dbt_yaml/value/de/
borrowed.rs

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

dbt_yaml/value/de/
borrowed.rs
