ron/de/
mod.rs

1/// Deserialization module.
2use std::{borrow::Cow, io, str};
3
4use base64::Engine;
5use serde::{
6    de::{self, DeserializeSeed, Deserializer as _, Visitor},
7    Deserialize,
8};
9
10use self::{id::IdDeserializer, tag::TagDeserializer};
11pub use crate::error::{Error, Position, SpannedError};
12use crate::{
13    error::{Result, SpannedResult},
14    extensions::Extensions,
15    options::Options,
16    parse::{AnyNum, Bytes, ParsedStr, BASE64_ENGINE},
17};
18
19mod id;
20mod tag;
21#[cfg(test)]
22mod tests;
23mod value;
24
25/// The RON deserializer.
26///
27/// If you just want to simply deserialize a value,
28/// you can use the [`from_str`] convenience function.
29pub struct Deserializer<'de> {
30    bytes: Bytes<'de>,
31    newtype_variant: bool,
32    last_identifier: Option<&'de str>,
33    recursion_limit: Option<usize>,
34}
35
36impl<'de> Deserializer<'de> {
37    // Cannot implement trait here since output is tied to input lifetime 'de.
38    #[allow(clippy::should_implement_trait)]
39    pub fn from_str(input: &'de str) -> SpannedResult<Self> {
40        Self::from_str_with_options(input, Options::default())
41    }
42
43    pub fn from_bytes(input: &'de [u8]) -> SpannedResult<Self> {
44        Self::from_bytes_with_options(input, Options::default())
45    }
46
47    pub fn from_str_with_options(input: &'de str, options: Options) -> SpannedResult<Self> {
48        Self::from_bytes_with_options(input.as_bytes(), options)
49    }
50
51    pub fn from_bytes_with_options(input: &'de [u8], options: Options) -> SpannedResult<Self> {
52        let mut deserializer = Deserializer {
53            bytes: Bytes::new(input)?,
54            newtype_variant: false,
55            last_identifier: None,
56            recursion_limit: options.recursion_limit,
57        };
58
59        deserializer.bytes.exts |= options.default_extensions;
60
61        Ok(deserializer)
62    }
63
64    pub fn remainder(&self) -> Cow<'_, str> {
65        String::from_utf8_lossy(self.bytes.bytes())
66    }
67
68    pub fn span_error(&self, code: Error) -> SpannedError {
69        self.bytes.span_error(code)
70    }
71}
72
73/// A convenience function for building a deserializer
74/// and deserializing a value of type `T` from a reader.
75pub fn from_reader<R, T>(rdr: R) -> SpannedResult<T>
76where
77    R: io::Read,
78    T: de::DeserializeOwned,
79{
80    Options::default().from_reader(rdr)
81}
82
83/// A convenience function for building a deserializer
84/// and deserializing a value of type `T` from a string.
85pub fn from_str<'a, T>(s: &'a str) -> SpannedResult<T>
86where
87    T: de::Deserialize<'a>,
88{
89    Options::default().from_str(s)
90}
91
92/// A convenience function for building a deserializer
93/// and deserializing a value of type `T` from bytes.
94pub fn from_bytes<'a, T>(s: &'a [u8]) -> SpannedResult<T>
95where
96    T: de::Deserialize<'a>,
97{
98    Options::default().from_bytes(s)
99}
100
101macro_rules! guard_recursion {
102    ($self:expr => $expr:expr) => {{
103        if let Some(limit) = &mut $self.recursion_limit {
104            if let Some(new_limit) = limit.checked_sub(1) {
105                *limit = new_limit;
106            } else {
107                return Err(Error::ExceededRecursionLimit);
108            }
109        }
110
111        let result = $expr;
112
113        if let Some(limit) = &mut $self.recursion_limit {
114            *limit = limit.saturating_add(1);
115        }
116
117        result
118    }};
119}
120
121impl<'de> Deserializer<'de> {
122    /// Check if the remaining bytes are whitespace only,
123    /// otherwise return an error.
124    pub fn end(&mut self) -> Result<()> {
125        self.bytes.skip_ws()?;
126
127        if self.bytes.bytes().is_empty() {
128            Ok(())
129        } else {
130            Err(Error::TrailingCharacters)
131        }
132    }
133
134    /// Called from [`deserialize_any`][serde::Deserializer::deserialize_any]
135    /// when a struct was detected. Decides if there is a unit, tuple or usual
136    /// struct and deserializes it accordingly.
137    ///
138    /// This method assumes there is no identifier left.
139    fn handle_any_struct<V>(&mut self, visitor: V) -> Result<V::Value>
140    where
141        V: Visitor<'de>,
142    {
143        // Create a working copy
144        let mut bytes = self.bytes;
145
146        if bytes.consume("(") {
147            bytes.skip_ws()?;
148
149            if bytes.check_tuple_struct()? {
150                // first argument is technically incorrect, but ignored anyway
151                self.deserialize_tuple(0, visitor)
152            } else {
153                // giving no name results in worse errors but is necessary here
154                self.handle_struct_after_name("", visitor)
155            }
156        } else {
157            visitor.visit_unit()
158        }
159    }
160
161    /// Called from
162    /// [`deserialize_struct`][serde::Deserializer::deserialize_struct],
163    /// [`struct_variant`][serde::de::VariantAccess::struct_variant], and
164    /// [`handle_any_struct`][Self::handle_any_struct]. Handles
165    /// deserialising the enclosing parentheses and everything in between.
166    ///
167    /// This method assumes there is no struct name identifier left.
168    fn handle_struct_after_name<V>(
169        &mut self,
170        name_for_pretty_errors_only: &'static str,
171        visitor: V,
172    ) -> Result<V::Value>
173    where
174        V: Visitor<'de>,
175    {
176        if self.newtype_variant || self.bytes.consume("(") {
177            let old_newtype_variant = self.newtype_variant;
178            self.newtype_variant = false;
179
180            let value = guard_recursion! { self =>
181                visitor
182                    .visit_map(CommaSeparated::new(b')', self))
183                    .map_err(|err| {
184                        struct_error_name(
185                            err,
186                            if !old_newtype_variant && !name_for_pretty_errors_only.is_empty() {
187                                Some(name_for_pretty_errors_only)
188                            } else {
189                                None
190                            },
191                        )
192                    })?
193            };
194
195            self.bytes.skip_ws()?;
196
197            if old_newtype_variant || self.bytes.consume(")") {
198                Ok(value)
199            } else {
200                Err(Error::ExpectedStructLikeEnd)
201            }
202        } else if name_for_pretty_errors_only.is_empty() {
203            Err(Error::ExpectedStructLike)
204        } else {
205            Err(Error::ExpectedNamedStructLike(name_for_pretty_errors_only))
206        }
207    }
208}
209
210impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
211    type Error = Error;
212
213    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
214    where
215        V: Visitor<'de>,
216    {
217        // Newtype variants can only be unwrapped if we receive information
218        //  about the wrapped type - with `deserialize_any` we don't
219        self.newtype_variant = false;
220
221        if self.bytes.consume_ident("true") {
222            return visitor.visit_bool(true);
223        } else if self.bytes.consume_ident("false") {
224            return visitor.visit_bool(false);
225        } else if self.bytes.check_ident("Some") {
226            return self.deserialize_option(visitor);
227        } else if self.bytes.consume_ident("None") {
228            return visitor.visit_none();
229        } else if self.bytes.consume("()") {
230            return visitor.visit_unit();
231        } else if self.bytes.consume_ident("inf") {
232            return visitor.visit_f64(std::f64::INFINITY);
233        } else if self.bytes.consume_ident("-inf") {
234            return visitor.visit_f64(std::f64::NEG_INFINITY);
235        } else if self.bytes.consume_ident("NaN") {
236            return visitor.visit_f64(std::f64::NAN);
237        }
238
239        // `identifier` does not change state if it fails
240        let ident = self.bytes.identifier().ok();
241
242        if ident.is_some() {
243            self.bytes.skip_ws()?;
244
245            return self.handle_any_struct(visitor);
246        }
247
248        match self.bytes.peek_or_eof()? {
249            b'(' => self.handle_any_struct(visitor),
250            b'[' => self.deserialize_seq(visitor),
251            b'{' => self.deserialize_map(visitor),
252            b'0'..=b'9' | b'+' | b'-' => {
253                let any_num: AnyNum = self.bytes.any_num()?;
254
255                match any_num {
256                    AnyNum::F32(x) => visitor.visit_f32(x),
257                    AnyNum::F64(x) => visitor.visit_f64(x),
258                    AnyNum::I8(x) => visitor.visit_i8(x),
259                    AnyNum::U8(x) => visitor.visit_u8(x),
260                    AnyNum::I16(x) => visitor.visit_i16(x),
261                    AnyNum::U16(x) => visitor.visit_u16(x),
262                    AnyNum::I32(x) => visitor.visit_i32(x),
263                    AnyNum::U32(x) => visitor.visit_u32(x),
264                    AnyNum::I64(x) => visitor.visit_i64(x),
265                    AnyNum::U64(x) => visitor.visit_u64(x),
266                    #[cfg(feature = "integer128")]
267                    AnyNum::I128(x) => visitor.visit_i128(x),
268                    #[cfg(feature = "integer128")]
269                    AnyNum::U128(x) => visitor.visit_u128(x),
270                }
271            }
272            b'.' => self.deserialize_f64(visitor),
273            b'"' | b'r' => self.deserialize_string(visitor),
274            b'\'' => self.deserialize_char(visitor),
275            other => Err(Error::UnexpectedByte(other as char)),
276        }
277    }
278
279    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value>
280    where
281        V: Visitor<'de>,
282    {
283        visitor.visit_bool(self.bytes.bool()?)
284    }
285
286    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value>
287    where
288        V: Visitor<'de>,
289    {
290        visitor.visit_i8(self.bytes.signed_integer()?)
291    }
292
293    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value>
294    where
295        V: Visitor<'de>,
296    {
297        visitor.visit_i16(self.bytes.signed_integer()?)
298    }
299
300    fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value>
301    where
302        V: Visitor<'de>,
303    {
304        visitor.visit_i32(self.bytes.signed_integer()?)
305    }
306
307    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value>
308    where
309        V: Visitor<'de>,
310    {
311        visitor.visit_i64(self.bytes.signed_integer()?)
312    }
313
314    #[cfg(feature = "integer128")]
315    fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value>
316    where
317        V: Visitor<'de>,
318    {
319        visitor.visit_i128(self.bytes.signed_integer()?)
320    }
321
322    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value>
323    where
324        V: Visitor<'de>,
325    {
326        visitor.visit_u8(self.bytes.unsigned_integer()?)
327    }
328
329    fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value>
330    where
331        V: Visitor<'de>,
332    {
333        visitor.visit_u16(self.bytes.unsigned_integer()?)
334    }
335
336    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value>
337    where
338        V: Visitor<'de>,
339    {
340        visitor.visit_u32(self.bytes.unsigned_integer()?)
341    }
342
343    fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value>
344    where
345        V: Visitor<'de>,
346    {
347        visitor.visit_u64(self.bytes.unsigned_integer()?)
348    }
349
350    #[cfg(feature = "integer128")]
351    fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value>
352    where
353        V: Visitor<'de>,
354    {
355        visitor.visit_u128(self.bytes.unsigned_integer()?)
356    }
357
358    fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value>
359    where
360        V: Visitor<'de>,
361    {
362        visitor.visit_f32(self.bytes.float()?)
363    }
364
365    fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value>
366    where
367        V: Visitor<'de>,
368    {
369        visitor.visit_f64(self.bytes.float()?)
370    }
371
372    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value>
373    where
374        V: Visitor<'de>,
375    {
376        visitor.visit_char(self.bytes.char()?)
377    }
378
379    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value>
380    where
381        V: Visitor<'de>,
382    {
383        match self.bytes.string()? {
384            ParsedStr::Allocated(s) => visitor.visit_string(s),
385            ParsedStr::Slice(s) => visitor.visit_borrowed_str(s),
386        }
387    }
388
389    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value>
390    where
391        V: Visitor<'de>,
392    {
393        self.deserialize_str(visitor)
394    }
395
396    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value>
397    where
398        V: Visitor<'de>,
399    {
400        self.deserialize_byte_buf(visitor)
401    }
402
403    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value>
404    where
405        V: Visitor<'de>,
406    {
407        if let Some(b'[') = self.bytes.peek() {
408            let bytes = Vec::<u8>::deserialize(self)?;
409            return visitor.visit_byte_buf(bytes);
410        }
411
412        let res = {
413            let string = self.bytes.string()?;
414            let base64_str = match string {
415                ParsedStr::Allocated(ref s) => s.as_str(),
416                ParsedStr::Slice(s) => s,
417            };
418            BASE64_ENGINE.decode(base64_str)
419        };
420
421        match res {
422            Ok(byte_buf) => visitor.visit_byte_buf(byte_buf),
423            Err(err) => Err(Error::Base64Error(err)),
424        }
425    }
426
427    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
428    where
429        V: Visitor<'de>,
430    {
431        if self.bytes.consume("None") {
432            visitor.visit_none()
433        } else if self.bytes.consume("Some") && {
434            self.bytes.skip_ws()?;
435            self.bytes.consume("(")
436        } {
437            self.bytes.skip_ws()?;
438
439            let v = guard_recursion! { self => visitor.visit_some(&mut *self)? };
440
441            self.bytes.comma()?;
442
443            if self.bytes.consume(")") {
444                Ok(v)
445            } else {
446                Err(Error::ExpectedOptionEnd)
447            }
448        } else if self.bytes.exts.contains(Extensions::IMPLICIT_SOME) {
449            guard_recursion! { self => visitor.visit_some(&mut *self) }
450        } else {
451            Err(Error::ExpectedOption)
452        }
453    }
454
455    // In Serde, unit means an anonymous value containing no data.
456    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value>
457    where
458        V: Visitor<'de>,
459    {
460        if self.newtype_variant || self.bytes.consume("()") {
461            self.newtype_variant = false;
462
463            visitor.visit_unit()
464        } else {
465            Err(Error::ExpectedUnit)
466        }
467    }
468
469    fn deserialize_unit_struct<V>(self, name: &'static str, visitor: V) -> Result<V::Value>
470    where
471        V: Visitor<'de>,
472    {
473        if self.newtype_variant || self.bytes.consume_struct_name(name)? {
474            self.newtype_variant = false;
475
476            visitor.visit_unit()
477        } else {
478            self.deserialize_unit(visitor)
479        }
480    }
481
482    fn deserialize_newtype_struct<V>(self, name: &'static str, visitor: V) -> Result<V::Value>
483    where
484        V: Visitor<'de>,
485    {
486        if self.bytes.exts.contains(Extensions::UNWRAP_NEWTYPES) || self.newtype_variant {
487            self.newtype_variant = false;
488
489            return guard_recursion! { self => visitor.visit_newtype_struct(&mut *self) };
490        }
491
492        self.bytes.consume_struct_name(name)?;
493
494        self.bytes.skip_ws()?;
495
496        if self.bytes.consume("(") {
497            self.bytes.skip_ws()?;
498            let value = guard_recursion! { self => visitor.visit_newtype_struct(&mut *self)? };
499            self.bytes.comma()?;
500
501            if self.bytes.consume(")") {
502                Ok(value)
503            } else {
504                Err(Error::ExpectedStructLikeEnd)
505            }
506        } else if name.is_empty() {
507            Err(Error::ExpectedStructLike)
508        } else {
509            Err(Error::ExpectedNamedStructLike(name))
510        }
511    }
512
513    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value>
514    where
515        V: Visitor<'de>,
516    {
517        self.newtype_variant = false;
518
519        if self.bytes.consume("[") {
520            let value = guard_recursion! { self =>
521                visitor.visit_seq(CommaSeparated::new(b']', self))?
522            };
523            self.bytes.skip_ws()?;
524
525            if self.bytes.consume("]") {
526                Ok(value)
527            } else {
528                Err(Error::ExpectedArrayEnd)
529            }
530        } else {
531            Err(Error::ExpectedArray)
532        }
533    }
534
535    fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value>
536    where
537        V: Visitor<'de>,
538    {
539        if self.newtype_variant || self.bytes.consume("(") {
540            let old_newtype_variant = self.newtype_variant;
541            self.newtype_variant = false;
542
543            let value = guard_recursion! { self =>
544                visitor.visit_seq(CommaSeparated::new(b')', self))?
545            };
546            self.bytes.skip_ws()?;
547
548            if old_newtype_variant || self.bytes.consume(")") {
549                Ok(value)
550            } else {
551                Err(Error::ExpectedStructLikeEnd)
552            }
553        } else {
554            Err(Error::ExpectedStructLike)
555        }
556    }
557
558    fn deserialize_tuple_struct<V>(
559        self,
560        name: &'static str,
561        len: usize,
562        visitor: V,
563    ) -> Result<V::Value>
564    where
565        V: Visitor<'de>,
566    {
567        if !self.newtype_variant {
568            self.bytes.consume_struct_name(name)?;
569        }
570
571        self.deserialize_tuple(len, visitor).map_err(|e| match e {
572            Error::ExpectedStructLike if !name.is_empty() => Error::ExpectedNamedStructLike(name),
573            e => e,
574        })
575    }
576
577    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value>
578    where
579        V: Visitor<'de>,
580    {
581        self.newtype_variant = false;
582
583        if self.bytes.consume("{") {
584            let value = guard_recursion! { self =>
585                visitor.visit_map(CommaSeparated::new(b'}', self))?
586            };
587            self.bytes.skip_ws()?;
588
589            if self.bytes.consume("}") {
590                Ok(value)
591            } else {
592                Err(Error::ExpectedMapEnd)
593            }
594        } else {
595            Err(Error::ExpectedMap)
596        }
597    }
598
599    fn deserialize_struct<V>(
600        self,
601        name: &'static str,
602        _fields: &'static [&'static str],
603        visitor: V,
604    ) -> Result<V::Value>
605    where
606        V: Visitor<'de>,
607    {
608        if !self.newtype_variant {
609            self.bytes.consume_struct_name(name)?;
610        }
611
612        self.bytes.skip_ws()?;
613
614        self.handle_struct_after_name(name, visitor)
615    }
616
617    fn deserialize_enum<V>(
618        self,
619        name: &'static str,
620        _variants: &'static [&'static str],
621        visitor: V,
622    ) -> Result<V::Value>
623    where
624        V: Visitor<'de>,
625    {
626        self.newtype_variant = false;
627
628        match guard_recursion! { self => visitor.visit_enum(Enum::new(self)) } {
629            Ok(value) => Ok(value),
630            Err(Error::NoSuchEnumVariant {
631                expected,
632                found,
633                outer: None,
634            }) if !name.is_empty() => Err(Error::NoSuchEnumVariant {
635                expected,
636                found,
637                outer: Some(String::from(name)),
638            }),
639            Err(e) => Err(e),
640        }
641    }
642
643    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value>
644    where
645        V: Visitor<'de>,
646    {
647        let identifier = str::from_utf8(self.bytes.identifier()?).map_err(Error::from)?;
648
649        self.last_identifier = Some(identifier);
650
651        visitor.visit_borrowed_str(identifier)
652    }
653
654    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value>
655    where
656        V: Visitor<'de>,
657    {
658        self.deserialize_any(visitor)
659    }
660}
661
662struct CommaSeparated<'a, 'de: 'a> {
663    de: &'a mut Deserializer<'de>,
664    terminator: u8,
665    had_comma: bool,
666}
667
668impl<'a, 'de> CommaSeparated<'a, 'de> {
669    fn new(terminator: u8, de: &'a mut Deserializer<'de>) -> Self {
670        CommaSeparated {
671            de,
672            terminator,
673            had_comma: true,
674        }
675    }
676
677    fn has_element(&mut self) -> Result<bool> {
678        self.de.bytes.skip_ws()?;
679
680        match (
681            self.had_comma,
682            self.de.bytes.peek_or_eof()? != self.terminator,
683        ) {
684            // Trailing comma, maybe has a next element
685            (true, has_element) => Ok(has_element),
686            // No trailing comma but terminator
687            (false, false) => Ok(false),
688            // No trailing comma or terminator
689            (false, true) => Err(Error::ExpectedComma),
690        }
691    }
692}
693
694impl<'de, 'a> de::SeqAccess<'de> for CommaSeparated<'a, 'de> {
695    type Error = Error;
696
697    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
698    where
699        T: DeserializeSeed<'de>,
700    {
701        if self.has_element()? {
702            let res = guard_recursion! { self.de => seed.deserialize(&mut *self.de)? };
703
704            self.had_comma = self.de.bytes.comma()?;
705
706            Ok(Some(res))
707        } else {
708            Ok(None)
709        }
710    }
711}
712
713impl<'de, 'a> de::MapAccess<'de> for CommaSeparated<'a, 'de> {
714    type Error = Error;
715
716    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
717    where
718        K: DeserializeSeed<'de>,
719    {
720        if self.has_element()? {
721            if self.terminator == b')' {
722                guard_recursion! { self.de =>
723                    seed.deserialize(&mut IdDeserializer::new(&mut *self.de)).map(Some)
724                }
725            } else {
726                guard_recursion! { self.de => seed.deserialize(&mut *self.de).map(Some) }
727            }
728        } else {
729            Ok(None)
730        }
731    }
732
733    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
734    where
735        V: DeserializeSeed<'de>,
736    {
737        self.de.bytes.skip_ws()?;
738
739        if self.de.bytes.consume(":") {
740            self.de.bytes.skip_ws()?;
741
742            let res = guard_recursion! { self.de =>
743                seed.deserialize(&mut TagDeserializer::new(&mut *self.de))?
744            };
745
746            self.had_comma = self.de.bytes.comma()?;
747
748            Ok(res)
749        } else {
750            Err(Error::ExpectedMapColon)
751        }
752    }
753}
754
755struct Enum<'a, 'de: 'a> {
756    de: &'a mut Deserializer<'de>,
757}
758
759impl<'a, 'de> Enum<'a, 'de> {
760    fn new(de: &'a mut Deserializer<'de>) -> Self {
761        Enum { de }
762    }
763}
764
765impl<'de, 'a> de::EnumAccess<'de> for Enum<'a, 'de> {
766    type Error = Error;
767    type Variant = Self;
768
769    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant)>
770    where
771        V: DeserializeSeed<'de>,
772    {
773        self.de.bytes.skip_ws()?;
774
775        let value = guard_recursion! { self.de => seed.deserialize(&mut *self.de)? };
776
777        Ok((value, self))
778    }
779}
780
781impl<'de, 'a> de::VariantAccess<'de> for Enum<'a, 'de> {
782    type Error = Error;
783
784    fn unit_variant(self) -> Result<()> {
785        Ok(())
786    }
787
788    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value>
789    where
790        T: DeserializeSeed<'de>,
791    {
792        let newtype_variant = self.de.last_identifier;
793
794        self.de.bytes.skip_ws()?;
795
796        if self.de.bytes.consume("(") {
797            self.de.bytes.skip_ws()?;
798
799            self.de.newtype_variant = self
800                .de
801                .bytes
802                .exts
803                .contains(Extensions::UNWRAP_VARIANT_NEWTYPES);
804
805            let val = guard_recursion! { self.de =>
806                seed
807                    .deserialize(&mut *self.de)
808                    .map_err(|err| struct_error_name(err, newtype_variant))?
809            };
810
811            self.de.newtype_variant = false;
812
813            self.de.bytes.comma()?;
814
815            if self.de.bytes.consume(")") {
816                Ok(val)
817            } else {
818                Err(Error::ExpectedStructLikeEnd)
819            }
820        } else {
821            Err(Error::ExpectedStructLike)
822        }
823    }
824
825    fn tuple_variant<V>(self, len: usize, visitor: V) -> Result<V::Value>
826    where
827        V: Visitor<'de>,
828    {
829        self.de.bytes.skip_ws()?;
830
831        self.de.deserialize_tuple(len, visitor)
832    }
833
834    fn struct_variant<V>(self, _fields: &'static [&'static str], visitor: V) -> Result<V::Value>
835    where
836        V: Visitor<'de>,
837    {
838        let struct_variant = self.de.last_identifier;
839
840        self.de.bytes.skip_ws()?;
841
842        self.de
843            .handle_struct_after_name("", visitor)
844            .map_err(|err| struct_error_name(err, struct_variant))
845    }
846}
847
848fn struct_error_name(error: Error, name: Option<&str>) -> Error {
849    match error {
850        Error::NoSuchStructField {
851            expected,
852            found,
853            outer: None,
854        } => Error::NoSuchStructField {
855            expected,
856            found,
857            outer: name.map(ToOwned::to_owned),
858        },
859        Error::MissingStructField { field, outer: None } => Error::MissingStructField {
860            field,
861            outer: name.map(ToOwned::to_owned),
862        },
863        Error::DuplicateStructField { field, outer: None } => Error::DuplicateStructField {
864            field,
865            outer: name.map(ToOwned::to_owned),
866        },
867        e => e,
868    }
869}
ron/de/mod.rs

ron/de/
mod.rs
