serde_path_to_error/
de.rs

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

serde_path_to_error/
de.rs
