serde_path_to_error/
de.rs

Help
1use crate::wrap::{Wrap, WrapVariant};
2use crate::{Chain, Error, Track};
3use serde::de::{self, Deserialize, DeserializeSeed, Visitor};
4use serde::serde_if_integer128;
5use std::fmt;
6
7/// Entry point. See [crate documentation][crate] for an example.
8pub fn deserialize<'de, D, T>(deserializer: D) -> Result<T, Error<D::Error>>
9where
10    D: de::Deserializer<'de>,
11    T: Deserialize<'de>,
12{
13    let mut track = Track::new();
14    match T::deserialize(Deserializer::new(deserializer, &mut track)) {
15        Ok(t) => Ok(t),
16        Err(err) => Err(Error {
17            path: track.path(),
18            original: err,
19        }),
20    }
21}
22
23/// Deserializer adapter that records path to deserialization errors.
24///
25/// # Example
26///
27/// ```
28/// # use serde_derive::Deserialize;
29/// #
30/// use serde::Deserialize;
31/// use std::collections::BTreeMap as Map;
32///
33/// #[derive(Deserialize)]
34/// struct Package {
35///     name: String,
36///     dependencies: Map<String, Dependency>,
37/// }
38///
39/// #[derive(Deserialize)]
40/// struct Dependency {
41///     version: String,
42/// }
43///
44/// fn main() {
45///     let j = r#"{
46///         "name": "demo",
47///         "dependencies": {
48///             "serde": {
49///                 "version": 1
50///             }
51///         }
52///     }"#;
53///
54///     // Some Deserializer.
55///     let jd = &mut serde_json::Deserializer::from_str(j);
56///
57///     let mut track = serde_path_to_error::Track::new();
58///     let pd = serde_path_to_error::Deserializer::new(jd, &mut track);
59///
60///     match Package::deserialize(pd) {
61///         Ok(_) => panic!("expected a type error"),
62///         Err(_) => {
63///             let path = track.path().to_string();
64///             assert_eq!(path, "dependencies.serde.version");
65///         }
66///     }
67/// }
68/// ```
69pub struct Deserializer<'a, 'b, D> {
70    de: D,
71    chain: Chain<'a>,
72    track: &'b Track,
73}
74
75impl<'a, 'b, D> Deserializer<'a, 'b, D> {
76    pub fn new(de: D, track: &'b mut Track) -> Self {
77        Deserializer {
78            de,
79            chain: Chain::Root,
80            track,
81        }
82    }
83}
84
85// Plain old forwarding impl.
86impl<'a, 'b, 'de, D> de::Deserializer<'de> for Deserializer<'a, 'b, D>
87where
88    D: de::Deserializer<'de>,
89{
90    type Error = D::Error;
91
92    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, D::Error>
93    where
94        V: Visitor<'de>,
95    {
96        let chain = self.chain;
97        let track = self.track;
98        self.de
99            .deserialize_any(Wrap::new(visitor, &chain, track))
100            .map_err(|err| track.trigger(&chain, err))
101    }
102
103    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, D::Error>
104    where
105        V: Visitor<'de>,
106    {
107        let chain = self.chain;
108        let track = self.track;
109        self.de
110            .deserialize_bool(Wrap::new(visitor, &chain, track))
111            .map_err(|err| track.trigger(&chain, err))
112    }
113
114    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, D::Error>
115    where
116        V: Visitor<'de>,
117    {
118        let chain = self.chain;
119        let track = self.track;
120        self.de
121            .deserialize_u8(Wrap::new(visitor, &chain, track))
122            .map_err(|err| track.trigger(&chain, err))
123    }
124
125    fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, D::Error>
126    where
127        V: Visitor<'de>,
128    {
129        let chain = self.chain;
130        let track = self.track;
131        self.de
132            .deserialize_u16(Wrap::new(visitor, &chain, track))
133            .map_err(|err| track.trigger(&chain, err))
134    }
135
136    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, D::Error>
137    where
138        V: Visitor<'de>,
139    {
140        let chain = self.chain;
141        let track = self.track;
142        self.de
143            .deserialize_u32(Wrap::new(visitor, &chain, track))
144            .map_err(|err| track.trigger(&chain, err))
145    }
146
147    fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, D::Error>
148    where
149        V: Visitor<'de>,
150    {
151        let chain = self.chain;
152        let track = self.track;
153        self.de
154            .deserialize_u64(Wrap::new(visitor, &chain, track))
155            .map_err(|err| track.trigger(&chain, err))
156    }
157
158    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, D::Error>
159    where
160        V: Visitor<'de>,
161    {
162        let chain = self.chain;
163        let track = self.track;
164        self.de
165            .deserialize_i8(Wrap::new(visitor, &chain, track))
166            .map_err(|err| track.trigger(&chain, err))
167    }
168
169    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, D::Error>
170    where
171        V: Visitor<'de>,
172    {
173        let chain = self.chain;
174        let track = self.track;
175        self.de
176            .deserialize_i16(Wrap::new(visitor, &chain, track))
177            .map_err(|err| track.trigger(&chain, err))
178    }
179
180    fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, D::Error>
181    where
182        V: Visitor<'de>,
183    {
184        let chain = self.chain;
185        let track = self.track;
186        self.de
187            .deserialize_i32(Wrap::new(visitor, &chain, track))
188            .map_err(|err| track.trigger(&chain, err))
189    }
190
191    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, D::Error>
192    where
193        V: Visitor<'de>,
194    {
195        let chain = self.chain;
196        let track = self.track;
197        self.de
198            .deserialize_i64(Wrap::new(visitor, &chain, track))
199            .map_err(|err| track.trigger(&chain, err))
200    }
201
202    serde_if_integer128! {
203        fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value, D::Error>
204        where
205            V: Visitor<'de>,
206        {
207            let chain = self.chain;
208            let track = self.track;
209            self.de
210                .deserialize_u128(Wrap::new(visitor, &chain, track))
211                .map_err(|err| track.trigger(&chain, err))
212        }
213
214        fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value, D::Error>
215        where
216            V: Visitor<'de>,
217        {
218            let chain = self.chain;
219            let track = self.track;
220            self.de
221                .deserialize_i128(Wrap::new(visitor, &chain, track))
222                .map_err(|err| track.trigger(&chain, err))
223        }
224    }
225
226    fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, D::Error>
227    where
228        V: Visitor<'de>,
229    {
230        let chain = self.chain;
231        let track = self.track;
232        self.de
233            .deserialize_f32(Wrap::new(visitor, &chain, track))
234            .map_err(|err| track.trigger(&chain, err))
235    }
236
237    fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, D::Error>
238    where
239        V: Visitor<'de>,
240    {
241        let chain = self.chain;
242        let track = self.track;
243        self.de
244            .deserialize_f64(Wrap::new(visitor, &chain, track))
245            .map_err(|err| track.trigger(&chain, err))
246    }
247
248    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, D::Error>
249    where
250        V: Visitor<'de>,
251    {
252        let chain = self.chain;
253        let track = self.track;
254        self.de
255            .deserialize_char(Wrap::new(visitor, &chain, track))
256            .map_err(|err| track.trigger(&chain, err))
257    }
258
259    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, D::Error>
260    where
261        V: Visitor<'de>,
262    {
263        let chain = self.chain;
264        let track = self.track;
265        self.de
266            .deserialize_str(Wrap::new(visitor, &chain, track))
267            .map_err(|err| track.trigger(&chain, err))
268    }
269
270    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, D::Error>
271    where
272        V: Visitor<'de>,
273    {
274        let chain = self.chain;
275        let track = self.track;
276        self.de
277            .deserialize_string(Wrap::new(visitor, &chain, track))
278            .map_err(|err| track.trigger(&chain, err))
279    }
280
281    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, D::Error>
282    where
283        V: Visitor<'de>,
284    {
285        let chain = self.chain;
286        let track = self.track;
287        self.de
288            .deserialize_bytes(Wrap::new(visitor, &chain, track))
289            .map_err(|err| track.trigger(&chain, err))
290    }
291
292    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, D::Error>
293    where
294        V: Visitor<'de>,
295    {
296        let chain = self.chain;
297        let track = self.track;
298        self.de
299            .deserialize_byte_buf(Wrap::new(visitor, &chain, track))
300            .map_err(|err| track.trigger(&chain, err))
301    }
302
303    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, D::Error>
304    where
305        V: Visitor<'de>,
306    {
307        let chain = self.chain;
308        let track = self.track;
309        self.de
310            .deserialize_option(Wrap::new(visitor, &chain, track))
311            .map_err(|err| track.trigger(&chain, err))
312    }
313
314    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, D::Error>
315    where
316        V: Visitor<'de>,
317    {
318        let chain = self.chain;
319        let track = self.track;
320        self.de
321            .deserialize_unit(Wrap::new(visitor, &chain, track))
322            .map_err(|err| track.trigger(&chain, err))
323    }
324
325    fn deserialize_unit_struct<V>(
326        self,
327        name: &'static str,
328        visitor: V,
329    ) -> Result<V::Value, D::Error>
330    where
331        V: Visitor<'de>,
332    {
333        let chain = self.chain;
334        let track = self.track;
335        self.de
336            .deserialize_unit_struct(name, Wrap::new(visitor, &chain, track))
337            .map_err(|err| track.trigger(&chain, err))
338    }
339
340    fn deserialize_newtype_struct<V>(
341        self,
342        name: &'static str,
343        visitor: V,
344    ) -> Result<V::Value, D::Error>
345    where
346        V: Visitor<'de>,
347    {
348        let chain = self.chain;
349        let track = self.track;
350        self.de
351            .deserialize_newtype_struct(name, Wrap::new(visitor, &chain, track))
352            .map_err(|err| track.trigger(&chain, err))
353    }
354
355    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, D::Error>
356    where
357        V: Visitor<'de>,
358    {
359        let chain = self.chain;
360        let track = self.track;
361        self.de
362            .deserialize_seq(Wrap::new(visitor, &chain, track))
363            .map_err(|err| track.trigger(&chain, err))
364    }
365
366    fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, D::Error>
367    where
368        V: Visitor<'de>,
369    {
370        let chain = self.chain;
371        let track = self.track;
372        self.de
373            .deserialize_tuple(len, Wrap::new(visitor, &chain, track))
374            .map_err(|err| track.trigger(&chain, err))
375    }
376
377    fn deserialize_tuple_struct<V>(
378        self,
379        name: &'static str,
380        len: usize,
381        visitor: V,
382    ) -> Result<V::Value, D::Error>
383    where
384        V: Visitor<'de>,
385    {
386        let chain = self.chain;
387        let track = self.track;
388        self.de
389            .deserialize_tuple_struct(name, len, Wrap::new(visitor, &chain, track))
390            .map_err(|err| track.trigger(&chain, err))
391    }
392
393    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, D::Error>
394    where
395        V: Visitor<'de>,
396    {
397        let chain = self.chain;
398        let track = self.track;
399        self.de
400            .deserialize_map(Wrap::new(visitor, &chain, track))
401            .map_err(|err| track.trigger(&chain, err))
402    }
403
404    fn deserialize_struct<V>(
405        self,
406        name: &'static str,
407        fields: &'static [&'static str],
408        visitor: V,
409    ) -> Result<V::Value, D::Error>
410    where
411        V: Visitor<'de>,
412    {
413        let chain = self.chain;
414        let track = self.track;
415        self.de
416            .deserialize_struct(name, fields, Wrap::new(visitor, &chain, track))
417            .map_err(|err| track.trigger(&chain, err))
418    }
419
420    fn deserialize_enum<V>(
421        self,
422        name: &'static str,
423        variants: &'static [&'static str],
424        visitor: V,
425    ) -> Result<V::Value, D::Error>
426    where
427        V: Visitor<'de>,
428    {
429        let chain = self.chain;
430        let track = self.track;
431        self.de
432            .deserialize_enum(name, variants, Wrap::new(visitor, &chain, track))
433            .map_err(|err| track.trigger(&chain, err))
434    }
435
436    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, D::Error>
437    where
438        V: Visitor<'de>,
439    {
440        let chain = self.chain;
441        let track = self.track;
442        self.de
443            .deserialize_ignored_any(Wrap::new(visitor, &chain, track))
444            .map_err(|err| track.trigger(&chain, err))
445    }
446
447    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, D::Error>
448    where
449        V: Visitor<'de>,
450    {
451        let chain = self.chain;
452        let track = self.track;
453        self.de
454            .deserialize_identifier(Wrap::new(visitor, &chain, track))
455            .map_err(|err| track.trigger(&chain, err))
456    }
457
458    fn is_human_readable(&self) -> bool {
459        self.de.is_human_readable()
460    }
461}
462
463// Forwarding impl to preserve context.
464impl<'a, 'b, 'de, X> Visitor<'de> for Wrap<'a, 'b, X>
465where
466    X: Visitor<'de>,
467{
468    type Value = X::Value;
469
470    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
471        self.delegate.expecting(formatter)
472    }
473
474    fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
475    where
476        E: de::Error,
477    {
478        let chain = self.chain;
479        let track = self.track;
480        self.delegate
481            .visit_bool(v)
482            .map_err(|err| track.trigger(chain, err))
483    }
484
485    fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E>
486    where
487        E: de::Error,
488    {
489        let chain = self.chain;
490        let track = self.track;
491        self.delegate
492            .visit_i8(v)
493            .map_err(|err| track.trigger(chain, err))
494    }
495
496    fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
497    where
498        E: de::Error,
499    {
500        let chain = self.chain;
501        let track = self.track;
502        self.delegate
503            .visit_i16(v)
504            .map_err(|err| track.trigger(chain, err))
505    }
506
507    fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
508    where
509        E: de::Error,
510    {
511        let chain = self.chain;
512        let track = self.track;
513        self.delegate
514            .visit_i32(v)
515            .map_err(|err| track.trigger(chain, err))
516    }
517
518    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
519    where
520        E: de::Error,
521    {
522        let chain = self.chain;
523        let track = self.track;
524        self.delegate
525            .visit_i64(v)
526            .map_err(|err| track.trigger(chain, err))
527    }
528
529    fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E>
530    where
531        E: de::Error,
532    {
533        let chain = self.chain;
534        let track = self.track;
535        self.delegate
536            .visit_u8(v)
537            .map_err(|err| track.trigger(chain, err))
538    }
539
540    fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
541    where
542        E: de::Error,
543    {
544        let chain = self.chain;
545        let track = self.track;
546        self.delegate
547            .visit_u16(v)
548            .map_err(|err| track.trigger(chain, err))
549    }
550
551    fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
552    where
553        E: de::Error,
554    {
555        let chain = self.chain;
556        let track = self.track;
557        self.delegate
558            .visit_u32(v)
559            .map_err(|err| track.trigger(chain, err))
560    }
561
562    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
563    where
564        E: de::Error,
565    {
566        let chain = self.chain;
567        let track = self.track;
568        self.delegate
569            .visit_u64(v)
570            .map_err(|err| track.trigger(chain, err))
571    }
572
573    serde_if_integer128! {
574        fn visit_i128<E>(self, v: i128) -> Result<Self::Value, E>
575        where
576            E: de::Error,
577        {
578            let chain = self.chain;
579            let track = self.track;
580            self.delegate
581                .visit_i128(v)
582                .map_err(|err| track.trigger(chain, err))
583        }
584
585        fn visit_u128<E>(self, v: u128) -> Result<Self::Value, E>
586        where
587            E: de::Error,
588        {
589            let chain = self.chain;
590            let track = self.track;
591            self.delegate
592                .visit_u128(v)
593                .map_err(|err| track.trigger(chain, err))
594        }
595    }
596
597    fn visit_f32<E>(self, v: f32) -> Result<Self::Value, E>
598    where
599        E: de::Error,
600    {
601        let chain = self.chain;
602        let track = self.track;
603        self.delegate
604            .visit_f32(v)
605            .map_err(|err| track.trigger(chain, err))
606    }
607
608    fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>
609    where
610        E: de::Error,
611    {
612        let chain = self.chain;
613        let track = self.track;
614        self.delegate
615            .visit_f64(v)
616            .map_err(|err| track.trigger(chain, err))
617    }
618
619    fn visit_char<E>(self, v: char) -> Result<Self::Value, E>
620    where
621        E: de::Error,
622    {
623        let chain = self.chain;
624        let track = self.track;
625        self.delegate
626            .visit_char(v)
627            .map_err(|err| track.trigger(chain, err))
628    }
629
630    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
631    where
632        E: de::Error,
633    {
634        let chain = self.chain;
635        let track = self.track;
636        self.delegate
637            .visit_str(v)
638            .map_err(|err| track.trigger(chain, err))
639    }
640
641    fn visit_borrowed_str<E>(self, v: &'de str) -> Result<Self::Value, E>
642    where
643        E: de::Error,
644    {
645        let chain = self.chain;
646        let track = self.track;
647        self.delegate
648            .visit_borrowed_str(v)
649            .map_err(|err| track.trigger(chain, err))
650    }
651
652    fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
653    where
654        E: de::Error,
655    {
656        let chain = self.chain;
657        let track = self.track;
658        self.delegate
659            .visit_string(v)
660            .map_err(|err| track.trigger(chain, err))
661    }
662
663    fn visit_unit<E>(self) -> Result<Self::Value, E>
664    where
665        E: de::Error,
666    {
667        let chain = self.chain;
668        let track = self.track;
669        self.delegate
670            .visit_unit()
671            .map_err(|err| track.trigger(chain, err))
672    }
673
674    fn visit_none<E>(self) -> Result<Self::Value, E>
675    where
676        E: de::Error,
677    {
678        let chain = self.chain;
679        let track = self.track;
680        self.delegate
681            .visit_none()
682            .map_err(|err| track.trigger(chain, err))
683    }
684
685    fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
686    where
687        D: de::Deserializer<'de>,
688    {
689        let chain = self.chain;
690        let track = self.track;
691        self.delegate
692            .visit_some(Deserializer {
693                de: deserializer,
694                chain: Chain::Some { parent: chain },
695                track,
696            })
697            .map_err(|err| track.trigger(chain, err))
698    }
699
700    fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
701    where
702        D: de::Deserializer<'de>,
703    {
704        let chain = self.chain;
705        let track = self.track;
706        self.delegate
707            .visit_newtype_struct(Deserializer {
708                de: deserializer,
709                chain: Chain::NewtypeStruct { parent: chain },
710                track,
711            })
712            .map_err(|err| track.trigger(chain, err))
713    }
714
715    fn visit_seq<V>(self, visitor: V) -> Result<Self::Value, V::Error>
716    where
717        V: de::SeqAccess<'de>,
718    {
719        let chain = self.chain;
720        let track = self.track;
721        self.delegate
722            .visit_seq(SeqAccess::new(visitor, chain, track))
723            .map_err(|err| track.trigger(chain, err))
724    }
725
726    fn visit_map<V>(self, visitor: V) -> Result<Self::Value, V::Error>
727    where
728        V: de::MapAccess<'de>,
729    {
730        let chain = self.chain;
731        let track = self.track;
732        self.delegate
733            .visit_map(MapAccess::new(visitor, chain, track))
734            .map_err(|err| track.trigger(chain, err))
735    }
736
737    fn visit_enum<V>(self, visitor: V) -> Result<Self::Value, V::Error>
738    where
739        V: de::EnumAccess<'de>,
740    {
741        let chain = self.chain;
742        let track = self.track;
743        self.delegate
744            .visit_enum(Wrap::new(visitor, chain, track))
745            .map_err(|err| track.trigger(chain, err))
746    }
747
748    fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
749    where
750        E: de::Error,
751    {
752        let chain = self.chain;
753        let track = self.track;
754        self.delegate
755            .visit_bytes(v)
756            .map_err(|err| track.trigger(chain, err))
757    }
758
759    fn visit_borrowed_bytes<E>(self, v: &'de [u8]) -> Result<Self::Value, E>
760    where
761        E: de::Error,
762    {
763        let chain = self.chain;
764        let track = self.track;
765        self.delegate
766            .visit_borrowed_bytes(v)
767            .map_err(|err| track.trigger(chain, err))
768    }
769
770    fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
771    where
772        E: de::Error,
773    {
774        let chain = self.chain;
775        let track = self.track;
776        self.delegate
777            .visit_byte_buf(v)
778            .map_err(|err| track.trigger(chain, err))
779    }
780}
781
782// Forwarding impl to preserve context.
783impl<'a, 'b, 'de, X> de::EnumAccess<'de> for Wrap<'a, 'b, X>
784where
785    X: de::EnumAccess<'de> + 'a,
786{
787    type Error = X::Error;
788    type Variant = WrapVariant<'a, 'b, X::Variant>;
789
790    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), X::Error>
791    where
792        V: DeserializeSeed<'de>,
793    {
794        let chain = self.chain;
795        let track = self.track;
796        let mut variant = None;
797        self.delegate
798            .variant_seed(CaptureKey::new(seed, &mut variant))
799            .map_err(|err| track.trigger(chain, err))
800            .map(move |(v, vis)| {
801                let chain = match variant {
802                    Some(variant) => Chain::Enum {
803                        parent: chain,
804                        variant,
805                    },
806                    None => Chain::NonStringKey { parent: chain },
807                };
808                (v, WrapVariant::new(vis, chain, track))
809            })
810    }
811}
812
813// Forwarding impl to preserve context.
814impl<'a, 'b, 'de, X> de::VariantAccess<'de> for WrapVariant<'a, 'b, X>
815where
816    X: de::VariantAccess<'de>,
817{
818    type Error = X::Error;
819
820    fn unit_variant(self) -> Result<(), X::Error> {
821        let chain = self.chain;
822        let track = self.track;
823        self.delegate
824            .unit_variant()
825            .map_err(|err| track.trigger(&chain, err))
826    }
827
828    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, X::Error>
829    where
830        T: DeserializeSeed<'de>,
831    {
832        let chain = self.chain;
833        let track = self.track;
834        let nested = Chain::NewtypeVariant { parent: &chain };
835        self.delegate
836            .newtype_variant_seed(TrackedSeed::new(seed, nested, track))
837            .map_err(|err| track.trigger(&chain, err))
838    }
839
840    fn tuple_variant<V>(self, len: usize, visitor: V) -> Result<V::Value, X::Error>
841    where
842        V: Visitor<'de>,
843    {
844        let chain = self.chain;
845        let track = self.track;
846        self.delegate
847            .tuple_variant(len, Wrap::new(visitor, &chain, track))
848            .map_err(|err| track.trigger(&chain, err))
849    }
850
851    fn struct_variant<V>(
852        self,
853        fields: &'static [&'static str],
854        visitor: V,
855    ) -> Result<V::Value, X::Error>
856    where
857        V: Visitor<'de>,
858    {
859        let chain = self.chain;
860        let track = self.track;
861        self.delegate
862            .struct_variant(fields, Wrap::new(visitor, &chain, track))
863            .map_err(|err| track.trigger(&chain, err))
864    }
865}
866
867// Seed that saves the string into the given optional during `visit_str` and
868// `visit_string`.
869struct CaptureKey<'a, X> {
870    delegate: X,
871    key: &'a mut Option<String>,
872}
873
874impl<'a, X> CaptureKey<'a, X> {
875    fn new(delegate: X, key: &'a mut Option<String>) -> Self {
876        CaptureKey { delegate, key }
877    }
878}
879
880// Forwarding impl.
881impl<'a, 'de, X> DeserializeSeed<'de> for CaptureKey<'a, X>
882where
883    X: DeserializeSeed<'de>,
884{
885    type Value = X::Value;
886
887    fn deserialize<D>(self, deserializer: D) -> Result<X::Value, D::Error>
888    where
889        D: de::Deserializer<'de>,
890    {
891        self.delegate
892            .deserialize(CaptureKey::new(deserializer, self.key))
893    }
894}
895
896// Forwarding impl.
897impl<'a, 'de, X> de::Deserializer<'de> for CaptureKey<'a, X>
898where
899    X: de::Deserializer<'de>,
900{
901    type Error = X::Error;
902
903    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, X::Error>
904    where
905        V: Visitor<'de>,
906    {
907        self.delegate
908            .deserialize_any(CaptureKey::new(visitor, self.key))
909    }
910
911    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, X::Error>
912    where
913        V: Visitor<'de>,
914    {
915        self.delegate
916            .deserialize_bool(CaptureKey::new(visitor, self.key))
917    }
918
919    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, X::Error>
920    where
921        V: Visitor<'de>,
922    {
923        self.delegate
924            .deserialize_u8(CaptureKey::new(visitor, self.key))
925    }
926
927    fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, X::Error>
928    where
929        V: Visitor<'de>,
930    {
931        self.delegate
932            .deserialize_u16(CaptureKey::new(visitor, self.key))
933    }
934
935    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, X::Error>
936    where
937        V: Visitor<'de>,
938    {
939        self.delegate
940            .deserialize_u32(CaptureKey::new(visitor, self.key))
941    }
942
943    fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, X::Error>
944    where
945        V: Visitor<'de>,
946    {
947        self.delegate
948            .deserialize_u64(CaptureKey::new(visitor, self.key))
949    }
950
951    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, X::Error>
952    where
953        V: Visitor<'de>,
954    {
955        self.delegate
956            .deserialize_i8(CaptureKey::new(visitor, self.key))
957    }
958
959    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, X::Error>
960    where
961        V: Visitor<'de>,
962    {
963        self.delegate
964            .deserialize_i16(CaptureKey::new(visitor, self.key))
965    }
966
967    fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, X::Error>
968    where
969        V: Visitor<'de>,
970    {
971        self.delegate
972            .deserialize_i32(CaptureKey::new(visitor, self.key))
973    }
974
975    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, X::Error>
976    where
977        V: Visitor<'de>,
978    {
979        self.delegate
980            .deserialize_i64(CaptureKey::new(visitor, self.key))
981    }
982
983    serde_if_integer128! {
984        fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value, X::Error>
985        where
986            V: Visitor<'de>,
987        {
988            self.delegate
989                .deserialize_u128(CaptureKey::new(visitor, self.key))
990        }
991
992        fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value, X::Error>
993        where
994            V: Visitor<'de>,
995        {
996            self.delegate
997                .deserialize_i128(CaptureKey::new(visitor, self.key))
998        }
999    }
1000
1001    fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, X::Error>
1002    where
1003        V: Visitor<'de>,
1004    {
1005        self.delegate
1006            .deserialize_f32(CaptureKey::new(visitor, self.key))
1007    }
1008
1009    fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, X::Error>
1010    where
1011        V: Visitor<'de>,
1012    {
1013        self.delegate
1014            .deserialize_f64(CaptureKey::new(visitor, self.key))
1015    }
1016
1017    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, X::Error>
1018    where
1019        V: Visitor<'de>,
1020    {
1021        self.delegate
1022            .deserialize_char(CaptureKey::new(visitor, self.key))
1023    }
1024
1025    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, X::Error>
1026    where
1027        V: Visitor<'de>,
1028    {
1029        self.delegate
1030            .deserialize_str(CaptureKey::new(visitor, self.key))
1031    }
1032
1033    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, X::Error>
1034    where
1035        V: Visitor<'de>,
1036    {
1037        self.delegate
1038            .deserialize_string(CaptureKey::new(visitor, self.key))
1039    }
1040
1041    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, X::Error>
1042    where
1043        V: Visitor<'de>,
1044    {
1045        self.delegate
1046            .deserialize_bytes(CaptureKey::new(visitor, self.key))
1047    }
1048
1049    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, X::Error>
1050    where
1051        V: Visitor<'de>,
1052    {
1053        self.delegate
1054            .deserialize_byte_buf(CaptureKey::new(visitor, self.key))
1055    }
1056
1057    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, X::Error>
1058    where
1059        V: Visitor<'de>,
1060    {
1061        self.delegate
1062            .deserialize_option(CaptureKey::new(visitor, self.key))
1063    }
1064
1065    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, X::Error>
1066    where
1067        V: Visitor<'de>,
1068    {
1069        self.delegate
1070            .deserialize_unit(CaptureKey::new(visitor, self.key))
1071    }
1072
1073    fn deserialize_unit_struct<V>(
1074        self,
1075        name: &'static str,
1076        visitor: V,
1077    ) -> Result<V::Value, X::Error>
1078    where
1079        V: Visitor<'de>,
1080    {
1081        self.delegate
1082            .deserialize_unit_struct(name, CaptureKey::new(visitor, self.key))
1083    }
1084
1085    fn deserialize_newtype_struct<V>(
1086        self,
1087        name: &'static str,
1088        visitor: V,
1089    ) -> Result<V::Value, X::Error>
1090    where
1091        V: Visitor<'de>,
1092    {
1093        self.delegate
1094            .deserialize_newtype_struct(name, CaptureKey::new(visitor, self.key))
1095    }
1096
1097    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, X::Error>
1098    where
1099        V: Visitor<'de>,
1100    {
1101        self.delegate
1102            .deserialize_seq(CaptureKey::new(visitor, self.key))
1103    }
1104
1105    fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, X::Error>
1106    where
1107        V: Visitor<'de>,
1108    {
1109        self.delegate
1110            .deserialize_tuple(len, CaptureKey::new(visitor, self.key))
1111    }
1112
1113    fn deserialize_tuple_struct<V>(
1114        self,
1115        name: &'static str,
1116        len: usize,
1117        visitor: V,
1118    ) -> Result<V::Value, X::Error>
1119    where
1120        V: Visitor<'de>,
1121    {
1122        self.delegate
1123            .deserialize_tuple_struct(name, len, CaptureKey::new(visitor, self.key))
1124    }
1125
1126    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, X::Error>
1127    where
1128        V: Visitor<'de>,
1129    {
1130        self.delegate
1131            .deserialize_map(CaptureKey::new(visitor, self.key))
1132    }
1133
1134    fn deserialize_struct<V>(
1135        self,
1136        name: &'static str,
1137        fields: &'static [&'static str],
1138        visitor: V,
1139    ) -> Result<V::Value, X::Error>
1140    where
1141        V: Visitor<'de>,
1142    {
1143        self.delegate
1144            .deserialize_struct(name, fields, CaptureKey::new(visitor, self.key))
1145    }
1146
1147    fn deserialize_enum<V>(
1148        self,
1149        name: &'static str,
1150        variants: &'static [&'static str],
1151        visitor: V,
1152    ) -> Result<V::Value, X::Error>
1153    where
1154        V: Visitor<'de>,
1155    {
1156        self.delegate
1157            .deserialize_enum(name, variants, CaptureKey::new(visitor, self.key))
1158    }
1159
1160    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, X::Error>
1161    where
1162        V: Visitor<'de>,
1163    {
1164        self.delegate
1165            .deserialize_ignored_any(CaptureKey::new(visitor, self.key))
1166    }
1167
1168    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, X::Error>
1169    where
1170        V: Visitor<'de>,
1171    {
1172        self.delegate
1173            .deserialize_identifier(CaptureKey::new(visitor, self.key))
1174    }
1175
1176    fn is_human_readable(&self) -> bool {
1177        self.delegate.is_human_readable()
1178    }
1179}
1180
1181// Forwarding impl except `visit_str` and `visit_string` which save the string.
1182impl<'a, 'de, X> Visitor<'de> for CaptureKey<'a, X>
1183where
1184    X: Visitor<'de>,
1185{
1186    type Value = X::Value;
1187
1188    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1189        self.delegate.expecting(formatter)
1190    }
1191
1192    fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
1193    where
1194        E: de::Error,
1195    {
1196        self.delegate.visit_bool(v)
1197    }
1198
1199    fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E>
1200    where
1201        E: de::Error,
1202    {
1203        self.delegate.visit_i8(v)
1204    }
1205
1206    fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
1207    where
1208        E: de::Error,
1209    {
1210        self.delegate.visit_i16(v)
1211    }
1212
1213    fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
1214    where
1215        E: de::Error,
1216    {
1217        self.delegate.visit_i32(v)
1218    }
1219
1220    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
1221    where
1222        E: de::Error,
1223    {
1224        self.delegate.visit_i64(v)
1225    }
1226
1227    fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E>
1228    where
1229        E: de::Error,
1230    {
1231        self.delegate.visit_u8(v)
1232    }
1233
1234    fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
1235    where
1236        E: de::Error,
1237    {
1238        self.delegate.visit_u16(v)
1239    }
1240
1241    fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
1242    where
1243        E: de::Error,
1244    {
1245        self.delegate.visit_u32(v)
1246    }
1247
1248    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
1249    where
1250        E: de::Error,
1251    {
1252        self.delegate.visit_u64(v)
1253    }
1254
1255    serde_if_integer128! {
1256        fn visit_i128<E>(self, v: i128) -> Result<Self::Value, E>
1257        where
1258            E: de::Error,
1259        {
1260            self.delegate.visit_i128(v)
1261        }
1262
1263        fn visit_u128<E>(self, v: u128) -> Result<Self::Value, E>
1264        where
1265            E: de::Error,
1266        {
1267            self.delegate.visit_u128(v)
1268        }
1269    }
1270
1271    fn visit_f32<E>(self, v: f32) -> Result<Self::Value, E>
1272    where
1273        E: de::Error,
1274    {
1275        self.delegate.visit_f32(v)
1276    }
1277
1278    fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>
1279    where
1280        E: de::Error,
1281    {
1282        self.delegate.visit_f64(v)
1283    }
1284
1285    fn visit_char<E>(self, v: char) -> Result<Self::Value, E>
1286    where
1287        E: de::Error,
1288    {
1289        self.delegate.visit_char(v)
1290    }
1291
1292    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
1293    where
1294        E: de::Error,
1295    {
1296        *self.key = Some(v.to_owned());
1297        self.delegate.visit_str(v)
1298    }
1299
1300    fn visit_borrowed_str<E>(self, v: &'de str) -> Result<Self::Value, E>
1301    where
1302        E: de::Error,
1303    {
1304        *self.key = Some(v.to_owned());
1305        self.delegate.visit_borrowed_str(v)
1306    }
1307
1308    fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
1309    where
1310        E: de::Error,
1311    {
1312        *self.key = Some(v.clone());
1313        self.delegate.visit_string(v)
1314    }
1315
1316    fn visit_unit<E>(self) -> Result<Self::Value, E>
1317    where
1318        E: de::Error,
1319    {
1320        self.delegate.visit_unit()
1321    }
1322
1323    fn visit_none<E>(self) -> Result<Self::Value, E>
1324    where
1325        E: de::Error,
1326    {
1327        self.delegate.visit_none()
1328    }
1329
1330    fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
1331    where
1332        D: de::Deserializer<'de>,
1333    {
1334        self.delegate.visit_some(deserializer)
1335    }
1336
1337    fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
1338    where
1339        D: de::Deserializer<'de>,
1340    {
1341        self.delegate.visit_newtype_struct(deserializer)
1342    }
1343
1344    fn visit_seq<V>(self, visitor: V) -> Result<Self::Value, V::Error>
1345    where
1346        V: de::SeqAccess<'de>,
1347    {
1348        self.delegate.visit_seq(visitor)
1349    }
1350
1351    fn visit_map<V>(self, visitor: V) -> Result<Self::Value, V::Error>
1352    where
1353        V: de::MapAccess<'de>,
1354    {
1355        self.delegate.visit_map(visitor)
1356    }
1357
1358    fn visit_enum<V>(self, visitor: V) -> Result<Self::Value, V::Error>
1359    where
1360        V: de::EnumAccess<'de>,
1361    {
1362        self.delegate.visit_enum(visitor)
1363    }
1364
1365    fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
1366    where
1367        E: de::Error,
1368    {
1369        self.delegate.visit_bytes(v)
1370    }
1371
1372    fn visit_borrowed_bytes<E>(self, v: &'de [u8]) -> Result<Self::Value, E>
1373    where
1374        E: de::Error,
1375    {
1376        self.delegate.visit_borrowed_bytes(v)
1377    }
1378
1379    fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
1380    where
1381        E: de::Error,
1382    {
1383        self.delegate.visit_byte_buf(v)
1384    }
1385}
1386
1387// Seed used for map values, sequence elements and newtype variants to track
1388// their path.
1389struct TrackedSeed<'a, 'b, X> {
1390    seed: X,
1391    chain: Chain<'a>,
1392    track: &'b Track,
1393}
1394
1395impl<'a, 'b, X> TrackedSeed<'a, 'b, X> {
1396    fn new(seed: X, chain: Chain<'a>, track: &'b Track) -> Self {
1397        TrackedSeed { seed, chain, track }
1398    }
1399}
1400
1401impl<'a, 'b, 'de, X> DeserializeSeed<'de> for TrackedSeed<'a, 'b, X>
1402where
1403    X: DeserializeSeed<'de>,
1404{
1405    type Value = X::Value;
1406
1407    fn deserialize<D>(self, deserializer: D) -> Result<X::Value, D::Error>
1408    where
1409        D: de::Deserializer<'de>,
1410    {
1411        let chain = self.chain;
1412        let track = self.track;
1413        self.seed
1414            .deserialize(Deserializer {
1415                de: deserializer,
1416                chain: chain.clone(),
1417                track,
1418            })
1419            .map_err(|err| track.trigger(&chain, err))
1420    }
1421}
1422
1423// Seq visitor that tracks the index of its elements.
1424struct SeqAccess<'a, 'b, X> {
1425    delegate: X,
1426    chain: &'a Chain<'a>,
1427    index: usize,
1428    track: &'b Track,
1429}
1430
1431impl<'a, 'b, X> SeqAccess<'a, 'b, X> {
1432    fn new(delegate: X, chain: &'a Chain<'a>, track: &'b Track) -> Self {
1433        SeqAccess {
1434            delegate,
1435            chain,
1436            index: 0,
1437            track,
1438        }
1439    }
1440}
1441
1442// Forwarding impl to preserve context.
1443impl<'a, 'b, 'de, X> de::SeqAccess<'de> for SeqAccess<'a, 'b, X>
1444where
1445    X: de::SeqAccess<'de>,
1446{
1447    type Error = X::Error;
1448
1449    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, X::Error>
1450    where
1451        T: DeserializeSeed<'de>,
1452    {
1453        let parent = self.chain;
1454        let chain = Chain::Seq {
1455            parent,
1456            index: self.index,
1457        };
1458        let track = self.track;
1459        self.index += 1;
1460        self.delegate
1461            .next_element_seed(TrackedSeed::new(seed, chain, track))
1462            .map_err(|err| track.trigger(parent, err))
1463    }
1464
1465    fn size_hint(&self) -> Option<usize> {
1466        self.delegate.size_hint()
1467    }
1468}
1469
1470// Map visitor that captures the string value of its keys and uses that to track
1471// the path to its values.
1472struct MapAccess<'a, 'b, X> {
1473    delegate: X,
1474    chain: &'a Chain<'a>,
1475    key: Option<String>,
1476    track: &'b Track,
1477}
1478
1479impl<'a, 'b, X> MapAccess<'a, 'b, X> {
1480    fn new(delegate: X, chain: &'a Chain<'a>, track: &'b Track) -> Self {
1481        MapAccess {
1482            delegate,
1483            chain,
1484            key: None,
1485            track,
1486        }
1487    }
1488}
1489
1490impl<'a, 'b, 'de, X> de::MapAccess<'de> for MapAccess<'a, 'b, X>
1491where
1492    X: de::MapAccess<'de>,
1493{
1494    type Error = X::Error;
1495
1496    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, X::Error>
1497    where
1498        K: DeserializeSeed<'de>,
1499    {
1500        let chain = self.chain;
1501        let track = self.track;
1502        let key = &mut self.key;
1503        self.delegate
1504            .next_key_seed(CaptureKey::new(seed, key))
1505            .map_err(|err| {
1506                let chain = match key.take() {
1507                    Some(key) => Chain::Map { parent: chain, key },
1508                    None => Chain::NonStringKey { parent: chain },
1509                };
1510                track.trigger(&chain, err)
1511            })
1512    }
1513
1514    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, X::Error>
1515    where
1516        V: DeserializeSeed<'de>,
1517    {
1518        let parent = self.chain;
1519        let chain = match self.key.take() {
1520            Some(key) => Chain::Map { parent, key },
1521            None => Chain::NonStringKey { parent },
1522        };
1523        let track = self.track;
1524        self.delegate
1525            .next_value_seed(TrackedSeed::new(seed, chain, track))
1526            .map_err(|err| track.trigger(parent, err))
1527    }
1528
1529    fn size_hint(&self) -> Option<usize> {
1530        self.delegate.size_hint()
1531    }
1532}
serde_path_to_error/de.rs

serde_path_to_error/
de.rs
