serde_path_to_error/
de.rs

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

serde_path_to_error/
de.rs
