ron/de/
mod.rs

1/// Deserialization module.
2use alloc::{
3    borrow::ToOwned,
4    string::{String, ToString},
5    vec::Vec,
6};
7use core::str;
8
9use serde::{
10    de::{self, DeserializeSeed, Deserializer as _, Visitor},
11    Deserialize,
12};
13
14pub use crate::error::{Error, Position, Span, SpannedError};
15use crate::{
16    error::{Result, SpannedResult},
17    extensions::Extensions,
18    options::Options,
19    parse::{NewtypeMode, ParsedByteStr, ParsedStr, Parser, StructType, TupleMode},
20    value::NumberDeserializer,
21};
22
23#[cfg(feature = "std")]
24use std::io;
25
26mod id;
27mod tag;
28#[cfg(test)]
29mod tests;
30mod value;
31
32/// The RON deserializer.
33///
34/// If you just want to simply deserialize a value,
35/// you can use the [`from_str`] convenience function.
36pub struct Deserializer<'de> {
37    pub(crate) parser: Parser<'de>,
38    newtype_variant: bool,
39    serde_content_newtype: bool,
40    last_identifier: Option<&'de str>,
41    recursion_limit: Option<usize>,
42}
43
44impl<'de> Deserializer<'de> {
45    // Cannot implement trait here since output is tied to input lifetime 'de.
46    #[allow(clippy::should_implement_trait)]
47    pub fn from_str(input: &'de str) -> SpannedResult<Self> {
48        Self::from_str_with_options(input, &Options::default())
49    }
50
51    pub fn from_bytes(input: &'de [u8]) -> SpannedResult<Self> {
52        Self::from_bytes_with_options(input, &Options::default())
53    }
54
55    pub fn from_str_with_options(input: &'de str, options: &Options) -> SpannedResult<Self> {
56        let mut deserializer = Deserializer {
57            parser: Parser::new(input)?,
58            newtype_variant: false,
59            serde_content_newtype: false,
60            last_identifier: None,
61            recursion_limit: options.recursion_limit,
62        };
63
64        deserializer.parser.exts |= options.default_extensions;
65
66        Ok(deserializer)
67    }
68
69    // FIXME: panic is not actually possible, remove once utf8_chunks is stabilized
70    #[allow(clippy::missing_panics_doc)]
71    pub fn from_bytes_with_options(input: &'de [u8], options: &Options) -> SpannedResult<Self> {
72        let err = match str::from_utf8(input) {
73            Ok(input) => return Self::from_str_with_options(input, options),
74            Err(err) => err,
75        };
76
77        // FIXME: use [`utf8_chunks`](https://github.com/rust-lang/rust/issues/99543) once stabilised
78        #[allow(clippy::expect_used)]
79        let valid_input =
80            str::from_utf8(&input[..err.valid_up_to()]).expect("source is valid up to error");
81
82        Err(SpannedError {
83            code: err.into(),
84            span: Span {
85                start: Position { line: 1, col: 1 },
86                end: Position::from_src_end(valid_input),
87            },
88        })
89    }
90
91    #[must_use]
92    pub fn remainder(&self) -> &'de str {
93        self.parser.src()
94    }
95
96    #[must_use]
97    pub fn span_error(&self, code: Error) -> SpannedError {
98        self.parser.span_error(code)
99    }
100
101    #[must_use]
102    pub fn extensions(&self) -> Extensions {
103        self.parser.exts
104    }
105}
106
107/// A convenience function for building a deserializer
108/// and deserializing a value of type `T` from a reader.
109#[cfg(feature = "std")]
110pub fn from_reader<R, T>(rdr: R) -> SpannedResult<T>
111where
112    R: io::Read,
113    T: de::DeserializeOwned,
114{
115    Options::default().from_reader(rdr)
116}
117
118/// A convenience function for building a deserializer
119/// and deserializing a value of type `T` from a string.
120pub fn from_str<'a, T>(s: &'a str) -> SpannedResult<T>
121where
122    T: de::Deserialize<'a>,
123{
124    Options::default().from_str(s)
125}
126
127/// A convenience function for building a deserializer
128/// and deserializing a value of type `T` from bytes.
129pub fn from_bytes<'a, T>(s: &'a [u8]) -> SpannedResult<T>
130where
131    T: de::Deserialize<'a>,
132{
133    Options::default().from_bytes(s)
134}
135
136/// A convenience function for deserializing a value of type `T`
137/// from a [`Value`](crate::Value).
138///
139/// Unlike the other convenience functions this returns a plain [`Error`]
140/// rather than a [`SpannedError`], since an in-memory [`Value`](crate::Value)
141/// has no source text to point a span into.
142pub fn from_value<T>(value: crate::Value) -> Result<T>
143where
144    T: de::DeserializeOwned,
145{
146    value.into_rust()
147}
148
149macro_rules! guard_recursion {
150    ($self:expr => $expr:expr) => {{
151        if let Some(limit) = &mut $self.recursion_limit {
152            if let Some(new_limit) = limit.checked_sub(1) {
153                *limit = new_limit;
154            } else {
155                return Err(Error::ExceededRecursionLimit);
156            }
157        }
158
159        let result = $expr;
160
161        if let Some(limit) = &mut $self.recursion_limit {
162            *limit = limit.saturating_add(1);
163        }
164
165        result
166    }};
167}
168
169impl<'de> Deserializer<'de> {
170    /// Check if the remaining bytes are whitespace only,
171    /// otherwise return an error.
172    pub fn end(&mut self) -> Result<()> {
173        self.parser.skip_ws()?;
174
175        if self.parser.src().is_empty() {
176            Ok(())
177        } else {
178            Err(Error::TrailingCharacters)
179        }
180    }
181
182    /// Called from [`deserialize_any`][serde::Deserializer::deserialize_any]
183    /// when a struct was detected. Decides if there is a unit, tuple or usual
184    /// struct and deserializes it accordingly.
185    ///
186    /// This method assumes there is no identifier left.
187    fn handle_any_struct<V>(&mut self, visitor: V, ident: Option<&str>) -> Result<V::Value>
188    where
189        V: Visitor<'de>,
190    {
191        // HACK: switch to JSON enum semantics for JSON content
192        // Robust impl blocked on https://github.com/serde-rs/serde/issues/1183
193        let is_serde_content =
194            is_serde_content::<V::Value>() || is_serde_tag_or_content::<V::Value>();
195
196        let old_serde_content_newtype = self.serde_content_newtype;
197        self.serde_content_newtype = false;
198
199        match (
200            self.parser.check_struct_type(
201                NewtypeMode::NoParensMeanUnit,
202                if old_serde_content_newtype {
203                    TupleMode::DifferentiateNewtype // separate match on NewtypeOrTuple below
204                } else {
205                    TupleMode::ImpreciseTupleOrNewtype // Tuple and NewtypeOrTuple match equally
206                },
207            )?,
208            ident,
209        ) {
210            (StructType::Unit, Some(ident)) if is_serde_content => {
211                // serde's Content type needs the ident for unit variants
212                visitor.visit_str(ident)
213            }
214            (StructType::Unit, _) => visitor.visit_unit(),
215            (_, Some(ident)) if is_serde_content => {
216                // serde's Content type uses a singleton map encoding for enums
217                guard_recursion! { self =>
218                    visitor.visit_map(SerdeEnumContent {
219                        de: &mut *self,
220                        ident: Some(ident),
221                    })
222                }
223            }
224            (StructType::Named, _) => {
225                // giving no name results in worse errors but is necessary here
226                self.handle_struct_after_name("", visitor)
227            }
228            (StructType::NewtypeTuple, _) if old_serde_content_newtype => {
229                // deserialize a newtype struct or variant
230                self.parser.consume_char('(');
231                self.parser.skip_ws()?;
232                let value = guard_recursion! { self => self.deserialize_any(visitor)? };
233                self.parser.comma()?;
234
235                if self.parser.consume_char(')') {
236                    Ok(value)
237                } else {
238                    Err(Error::ExpectedStructLikeEnd)
239                }
240            }
241            (
242                StructType::AnyTuple
243                | StructType::EmptyTuple
244                | StructType::NewtypeTuple
245                | StructType::NonNewtypeTuple,
246                _,
247            ) => {
248                // first argument is technically incorrect, but ignored anyway
249                self.deserialize_tuple(0, visitor)
250            }
251        }
252    }
253
254    fn handle_float_range_or_value<V>(
255        &mut self,
256        number: crate::value::Number,
257        visitor: V,
258    ) -> Result<V::Value>
259    where
260        V: Visitor<'de>,
261    {
262        if self.parser.consume_str("..=") {
263            let end = self.parser.any_number()?;
264            return visitor.visit_map(RangeMapAccess::new(number, end, "end"));
265        } else if self.parser.consume_str("..") {
266            if !self.parser.check_any_number_start() {
267                return visitor.visit_map(RangeFromMapAccess::new(number));
268            }
269            let end = self.parser.any_number()?;
270            return visitor.visit_map(RangeMapAccess::new(number, end, "end"));
271        }
272        number.visit(visitor)
273    }
274
275    /// Called from
276    /// [`deserialize_struct`][serde::Deserializer::deserialize_struct],
277    /// [`struct_variant`][serde::de::VariantAccess::struct_variant], and
278    /// [`handle_any_struct`][Self::handle_any_struct]. Handles
279    /// deserialising the enclosing parentheses and everything in between.
280    ///
281    /// This method assumes there is no struct name identifier left.
282    fn handle_struct_after_name<V>(
283        &mut self,
284        name_for_pretty_errors_only: &'static str,
285        visitor: V,
286    ) -> Result<V::Value>
287    where
288        V: Visitor<'de>,
289    {
290        if self.newtype_variant || self.parser.consume_char('(') {
291            let old_newtype_variant = self.newtype_variant;
292            self.newtype_variant = false;
293
294            let value = guard_recursion! { self =>
295                visitor
296                    .visit_map(CommaSeparated::new(Terminator::Struct, self))
297                    .map_err(|err| {
298                        struct_error_name(
299                            err,
300                            if !old_newtype_variant && !name_for_pretty_errors_only.is_empty() {
301                                Some(name_for_pretty_errors_only)
302                            } else {
303                                None
304                            },
305                        )
306                    })?
307            };
308
309            self.parser.skip_ws()?;
310
311            if old_newtype_variant || self.parser.consume_char(')') {
312                Ok(value)
313            } else {
314                Err(Error::ExpectedStructLikeEnd)
315            }
316        } else if name_for_pretty_errors_only.is_empty() {
317            Err(Error::ExpectedStructLike)
318        } else {
319            Err(Error::ExpectedNamedStructLike(name_for_pretty_errors_only))
320        }
321    }
322}
323
324impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
325    type Error = Error;
326
327    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
328    where
329        V: Visitor<'de>,
330    {
331        if self.newtype_variant {
332            if self.parser.check_char(')') {
333                // newtype variant wraps the unit type / a unit struct without name
334                return self.deserialize_unit(visitor);
335            }
336
337            #[allow(clippy::wildcard_in_or_patterns)]
338            match self
339                .parser
340                .check_struct_type(NewtypeMode::InsideNewtype, TupleMode::DifferentiateNewtype)?
341            {
342                StructType::Named => {
343                    // newtype variant wraps a named struct
344                    // giving no name results in worse errors but is necessary here
345                    return self.handle_struct_after_name("", visitor);
346                }
347                StructType::EmptyTuple | StructType::NonNewtypeTuple => {
348                    // newtype variant wraps a tuple (struct)
349                    // first argument is technically incorrect, but ignored anyway
350                    return self.deserialize_tuple(0, visitor);
351                }
352                // StructType::Unit is impossible with NewtypeMode::InsideNewtype
353                // StructType::AnyTuple is impossible with TupleMode::DifferentiateNewtype
354                StructType::NewtypeTuple | _ => {
355                    // continue as usual with the inner content of the newtype variant
356                    self.newtype_variant = false;
357                }
358            }
359        }
360
361        if self.parser.consume_ident("true") {
362            return visitor.visit_bool(true);
363        } else if self.parser.consume_ident("false") {
364            return visitor.visit_bool(false);
365        } else if self.parser.check_ident("Some") {
366            return self.deserialize_option(visitor);
367        } else if self.parser.consume_ident("None") {
368            return visitor.visit_none();
369        } else if self.parser.consume_str("()") {
370            return visitor.visit_unit();
371        } else if self.parser.consume_ident("inf") || self.parser.consume_ident("inff32") {
372            let number = crate::value::Number::F32(crate::value::F32(core::f32::INFINITY));
373            return self.handle_float_range_or_value(number, visitor);
374        } else if self.parser.consume_ident("inff64") {
375            let number = crate::value::Number::F64(crate::value::F64(core::f64::INFINITY));
376            return self.handle_float_range_or_value(number, visitor);
377        } else if self.parser.consume_ident("NaN") || self.parser.consume_ident("NaNf32") {
378            let number = crate::value::Number::F32(crate::value::F32(core::f32::NAN));
379            return self.handle_float_range_or_value(number, visitor);
380        } else if self.parser.consume_ident("NaNf64") {
381            let number = crate::value::Number::F64(crate::value::F64(core::f64::NAN));
382            return self.handle_float_range_or_value(number, visitor);
383        }
384
385        // `skip_identifier` does not change state if it fails
386        if let Some(ident) = self.parser.skip_identifier() {
387            self.parser.skip_ws()?;
388
389            return self.handle_any_struct(visitor, Some(ident));
390        }
391
392        match self.parser.peek_char_or_eof()? {
393            '(' => self.handle_any_struct(visitor, None),
394            '[' => self.deserialize_seq(visitor),
395            '{' => self.deserialize_map(visitor),
396            '0'..='9' | '+' | '-' | '.' | 'b' => {
397                if self.parser.check_char('b') && !self.parser.src().starts_with("b'") {
398                    return self.deserialize_byte_buf(visitor);
399                }
400
401                if self.parser.check_str("..=") {
402                    self.parser.consume_str("..=");
403                    let end = self.parser.any_number()?;
404                    return visitor.visit_map(RangeToMapAccess::new(end, "end"));
405                }
406
407                if self.parser.consume_str("..") {
408                    if self.parser.check_any_number_start() {
409                        let end = self.parser.any_number()?;
410                        return visitor.visit_map(RangeToMapAccess::new(end, "end"));
411                    }
412                    return visitor.visit_unit();
413                }
414
415                let start = self.parser.any_number()?;
416
417                self.handle_float_range_or_value(start, visitor)
418            }
419            '"' | 'r' => self.deserialize_string(visitor),
420            '\'' => self.deserialize_char(visitor),
421            other => Err(Error::UnexpectedChar(other)),
422        }
423    }
424
425    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value>
426    where
427        V: Visitor<'de>,
428    {
429        visitor.visit_bool(self.parser.bool()?)
430    }
431
432    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value>
433    where
434        V: Visitor<'de>,
435    {
436        visitor.visit_i8(self.parser.integer()?)
437    }
438
439    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value>
440    where
441        V: Visitor<'de>,
442    {
443        visitor.visit_i16(self.parser.integer()?)
444    }
445
446    fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value>
447    where
448        V: Visitor<'de>,
449    {
450        visitor.visit_i32(self.parser.integer()?)
451    }
452
453    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value>
454    where
455        V: Visitor<'de>,
456    {
457        visitor.visit_i64(self.parser.integer()?)
458    }
459
460    #[cfg(feature = "integer128")]
461    fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value>
462    where
463        V: Visitor<'de>,
464    {
465        visitor.visit_i128(self.parser.integer()?)
466    }
467
468    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value>
469    where
470        V: Visitor<'de>,
471    {
472        visitor.visit_u8(self.parser.integer()?)
473    }
474
475    fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value>
476    where
477        V: Visitor<'de>,
478    {
479        visitor.visit_u16(self.parser.integer()?)
480    }
481
482    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value>
483    where
484        V: Visitor<'de>,
485    {
486        visitor.visit_u32(self.parser.integer()?)
487    }
488
489    fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value>
490    where
491        V: Visitor<'de>,
492    {
493        visitor.visit_u64(self.parser.integer()?)
494    }
495
496    #[cfg(feature = "integer128")]
497    fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value>
498    where
499        V: Visitor<'de>,
500    {
501        visitor.visit_u128(self.parser.integer()?)
502    }
503
504    fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value>
505    where
506        V: Visitor<'de>,
507    {
508        visitor.visit_f32(self.parser.float()?)
509    }
510
511    fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value>
512    where
513        V: Visitor<'de>,
514    {
515        visitor.visit_f64(self.parser.float()?)
516    }
517
518    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value>
519    where
520        V: Visitor<'de>,
521    {
522        visitor.visit_char(self.parser.char()?)
523    }
524
525    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value>
526    where
527        V: Visitor<'de>,
528    {
529        match self.parser.string()? {
530            ParsedStr::Allocated(s) => visitor.visit_string(s),
531            ParsedStr::Slice(s) => visitor.visit_borrowed_str(s),
532        }
533    }
534
535    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value>
536    where
537        V: Visitor<'de>,
538    {
539        self.deserialize_str(visitor)
540    }
541
542    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value>
543    where
544        V: Visitor<'de>,
545    {
546        self.deserialize_byte_buf(visitor)
547    }
548
549    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value>
550    where
551        V: Visitor<'de>,
552    {
553        if self.parser.check_char('[') {
554            let bytes = Vec::<u8>::deserialize(self)?;
555            return visitor.visit_byte_buf(bytes);
556        }
557
558        match self.parser.byte_string()? {
559            ParsedByteStr::Allocated(byte_buf) => visitor.visit_byte_buf(byte_buf),
560            ParsedByteStr::Slice(bytes) => visitor.visit_borrowed_bytes(bytes),
561        }
562    }
563
564    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
565    where
566        V: Visitor<'de>,
567    {
568        if self.parser.consume_ident("None") {
569            visitor.visit_none()
570        } else if self.parser.consume_ident("Some") && {
571            self.parser.skip_ws()?;
572            self.parser.consume_char('(')
573        } {
574            self.parser.skip_ws()?;
575
576            self.newtype_variant = self
577                .parser
578                .exts
579                .contains(Extensions::UNWRAP_VARIANT_NEWTYPES);
580
581            let v = guard_recursion! { self => visitor.visit_some(&mut *self)? };
582
583            self.newtype_variant = false;
584
585            self.parser.comma()?;
586
587            if self.parser.consume_char(')') {
588                Ok(v)
589            } else {
590                Err(Error::ExpectedOptionEnd)
591            }
592        } else if self.parser.exts.contains(Extensions::IMPLICIT_SOME) {
593            guard_recursion! { self => visitor.visit_some(&mut *self) }
594        } else {
595            Err(Error::ExpectedOption)
596        }
597    }
598
599    // In Serde, unit means an anonymous value containing no data.
600    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value>
601    where
602        V: Visitor<'de>,
603    {
604        if self.newtype_variant || self.parser.consume_str("()") {
605            self.newtype_variant = false;
606
607            visitor.visit_unit()
608        } else {
609            Err(Error::ExpectedUnit)
610        }
611    }
612
613    fn deserialize_unit_struct<V>(self, name: &'static str, visitor: V) -> Result<V::Value>
614    where
615        V: Visitor<'de>,
616    {
617        if name == "RangeFull" && self.parser.consume_str("..") {
618            return visitor.visit_unit();
619        }
620
621        if self.newtype_variant || self.parser.consume_struct_name(name)? {
622            self.newtype_variant = false;
623
624            visitor.visit_unit()
625        } else {
626            self.deserialize_unit(visitor)
627        }
628    }
629
630    fn deserialize_newtype_struct<V>(self, name: &'static str, visitor: V) -> Result<V::Value>
631    where
632        V: Visitor<'de>,
633    {
634        if name == crate::value::raw::RAW_VALUE_TOKEN {
635            let src_before = self.parser.pre_ws_src();
636            let is_nested = !self.parser.is_at_start();
637            self.parser.skip_ws()?;
638            let _ignored = self.deserialize_ignored_any(de::IgnoredAny)?;
639            let src_value_end = self.parser.src();
640            self.parser.skip_ws()?;
641            let src_after = self.parser.src();
642
643            if self.parser.has_unclosed_line_comment() {
644                return Err(Error::UnclosedLineComment);
645            }
646
647            let ron_str = if is_nested {
648                trim_raw_value_whitespace(src_before, src_value_end, src_after)
649            } else {
650                &src_before[..src_before.len() - src_after.len()]
651            };
652
653            return visitor
654                .visit_borrowed_str::<Error>(ron_str)
655                .map_err(|_| Error::ExpectedRawValue);
656        }
657
658        if self.parser.exts.contains(Extensions::UNWRAP_NEWTYPES) || self.newtype_variant {
659            self.newtype_variant = false;
660
661            return guard_recursion! { self => visitor.visit_newtype_struct(&mut *self) };
662        }
663
664        self.parser.consume_struct_name(name)?;
665
666        self.parser.skip_ws()?;
667
668        if self.parser.consume_char('(') {
669            self.parser.skip_ws()?;
670            let value = guard_recursion! { self => visitor.visit_newtype_struct(&mut *self)? };
671            self.parser.comma()?;
672
673            if self.parser.consume_char(')') {
674                Ok(value)
675            } else {
676                Err(Error::ExpectedStructLikeEnd)
677            }
678        } else if name.is_empty() {
679            Err(Error::ExpectedStructLike)
680        } else {
681            Err(Error::ExpectedNamedStructLike(name))
682        }
683    }
684
685    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value>
686    where
687        V: Visitor<'de>,
688    {
689        self.newtype_variant = false;
690
691        if self.parser.consume_char('[') {
692            let value = guard_recursion! { self =>
693                visitor.visit_seq(CommaSeparated::new(Terminator::Seq, self))?
694            };
695            self.parser.skip_ws()?;
696
697            if self.parser.consume_char(']') {
698                Ok(value)
699            } else {
700                Err(Error::ExpectedArrayEnd)
701            }
702        } else {
703            Err(Error::ExpectedArray)
704        }
705    }
706
707    fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value>
708    where
709        V: Visitor<'de>,
710    {
711        if self.newtype_variant || self.parser.consume_char('(') {
712            let old_newtype_variant = self.newtype_variant;
713            self.newtype_variant = false;
714
715            let value = guard_recursion! { self =>
716                visitor.visit_seq(CommaSeparated::new(Terminator::Tuple, self))?
717            };
718            self.parser.skip_ws()?;
719
720            if old_newtype_variant || self.parser.consume_char(')') {
721                Ok(value)
722            } else {
723                Err(Error::ExpectedStructLikeEnd)
724            }
725        } else {
726            Err(Error::ExpectedStructLike)
727        }
728    }
729
730    fn deserialize_tuple_struct<V>(
731        self,
732        name: &'static str,
733        len: usize,
734        visitor: V,
735    ) -> Result<V::Value>
736    where
737        V: Visitor<'de>,
738    {
739        if !self.newtype_variant {
740            self.parser.consume_struct_name(name)?;
741        }
742
743        self.deserialize_tuple(len, visitor).map_err(|e| match e {
744            Error::ExpectedStructLike if !name.is_empty() => Error::ExpectedNamedStructLike(name),
745            e => e,
746        })
747    }
748
749    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value>
750    where
751        V: Visitor<'de>,
752    {
753        struct VisitorExpecting<V>(V);
754        impl<'de, V: Visitor<'de>> core::fmt::Display for VisitorExpecting<&'_ V> {
755            fn fmt(&self, fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
756                self.0.expecting(fmt)
757            }
758        }
759
760        self.newtype_variant = false;
761
762        // TODO: Avoid allocating to perform this check.
763        let serde_flatten_canary = VisitorExpecting(&visitor)
764            .to_string()
765            .starts_with("struct ");
766
767        let terminator = if serde_flatten_canary {
768            Terminator::MapAsStruct
769        } else {
770            Terminator::Map
771        };
772
773        if self.parser.consume_char('{') {
774            let value = guard_recursion! { self =>
775                visitor.visit_map(CommaSeparated::new(terminator, self))?
776            };
777            self.parser.skip_ws()?;
778
779            if self.parser.consume_char('}') {
780                Ok(value)
781            } else {
782                Err(Error::ExpectedMapEnd)
783            }
784        } else {
785            Err(Error::ExpectedMap)
786        }
787    }
788
789    fn deserialize_struct<V>(
790        self,
791        name: &'static str,
792        fields: &'static [&'static str],
793        visitor: V,
794    ) -> Result<V::Value>
795    where
796        V: Visitor<'de>,
797    {
798        // `RangeInclusive` used `last` as field name before it was renamed to `end` in a newer Rust version
799        if (name == "Range" && fields == ["start", "end"])
800            || (name == "RangeInclusive" && matches!(fields, ["start", "end" | "last"]))
801        {
802            let end_field = fields[1];
803            if self.parser.check_any_number_start() {
804                let start = self.parser.any_number()?;
805
806                let inclusive = if self.parser.consume_str("..=") {
807                    true
808                } else if self.parser.consume_str("..") {
809                    false
810                } else {
811                    return Err(Error::ExpectedRangeSyntax);
812                };
813
814                if inclusive && name == "Range" {
815                    return Err(Error::Message(String::from(
816                        "expected `..` for `Range`, found `..=`",
817                    )));
818                }
819                if !inclusive && name == "RangeInclusive" {
820                    return Err(Error::Message(String::from(
821                        "expected `..=` for `RangeInclusive`, found `..`",
822                    )));
823                }
824
825                let end = self.parser.any_number()?;
826                return visitor.visit_map(RangeMapAccess::new(start, end, end_field));
827            }
828        }
829
830        if fields == ["start"] && name == "RangeFrom" && self.parser.check_any_number_start() {
831            let start = self.parser.any_number()?;
832            if self.parser.consume_str("..=") {
833                return Err(Error::Message(String::from(
834                    "expected `..` for `RangeFrom`, found `..=`",
835                )));
836            } else if !self.parser.consume_str("..") {
837                return Err(Error::ExpectedRangeSyntax);
838            }
839            return visitor.visit_map(RangeFromMapAccess::new(start));
840        }
841
842        if fields == ["end"]
843            && name == "RangeTo"
844            && (self.parser.check_str("..=") || self.parser.check_str(".."))
845        {
846            if self.parser.consume_str("..=") {
847                return Err(Error::Message(String::from(
848                    "expected `..` for `RangeTo`, found `..=`",
849                )));
850            }
851            self.parser.consume_str("..");
852            let end = self.parser.any_number()?;
853            return visitor.visit_map(RangeToMapAccess::new(end, "end"));
854        }
855
856        // `last` is the old field name for `RangeToInclusive`, replaced by `end` in a newer Rust version
857        if matches!(fields, ["end" | "last"])
858            && name == "RangeToInclusive"
859            && (self.parser.check_str("..=") || self.parser.check_str(".."))
860        {
861            if !self.parser.consume_str("..=") {
862                self.parser.consume_str("..");
863                return Err(Error::Message(String::from(
864                    "expected `..=` for `RangeToInclusive`, found `..`",
865                )));
866            }
867            let end = self.parser.any_number()?;
868            return visitor.visit_map(RangeToMapAccess::new(end, fields[0]));
869        }
870
871        if !self.newtype_variant {
872            self.parser.consume_struct_name(name)?;
873        }
874
875        self.parser.skip_ws()?;
876
877        self.handle_struct_after_name(name, visitor)
878    }
879
880    fn deserialize_enum<V>(
881        self,
882        name: &'static str,
883        _variants: &'static [&'static str],
884        visitor: V,
885    ) -> Result<V::Value>
886    where
887        V: Visitor<'de>,
888    {
889        self.newtype_variant = false;
890
891        match guard_recursion! { self => visitor.visit_enum(Enum::new(self)) } {
892            Ok(value) => Ok(value),
893            Err(Error::NoSuchEnumVariant {
894                expected,
895                found,
896                outer: None,
897            }) if !name.is_empty() => Err(Error::NoSuchEnumVariant {
898                expected,
899                found,
900                outer: Some(String::from(name)),
901            }),
902            Err(e) => Err(e),
903        }
904    }
905
906    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value>
907    where
908        V: Visitor<'de>,
909    {
910        let identifier = self.parser.identifier()?;
911
912        self.last_identifier = Some(identifier);
913
914        visitor.visit_borrowed_str(identifier)
915    }
916
917    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value>
918    where
919        V: Visitor<'de>,
920    {
921        self.deserialize_any(visitor)
922    }
923}
924
925enum Terminator {
926    Map,
927    MapAsStruct,
928    Tuple,
929    Struct,
930    Seq,
931}
932
933impl Terminator {
934    fn as_char(&self) -> char {
935        match self {
936            Terminator::Map | Terminator::MapAsStruct => '}',
937            Terminator::Tuple | Terminator::Struct => ')',
938            Terminator::Seq => ']',
939        }
940    }
941}
942
943struct CommaSeparated<'a, 'de: 'a> {
944    de: &'a mut Deserializer<'de>,
945    terminator: Terminator,
946    had_comma: bool,
947    inside_internally_tagged_enum: bool,
948}
949
950impl<'a, 'de> CommaSeparated<'a, 'de> {
951    fn new(terminator: Terminator, de: &'a mut Deserializer<'de>) -> Self {
952        CommaSeparated {
953            de,
954            terminator,
955            had_comma: true,
956            inside_internally_tagged_enum: false,
957        }
958    }
959
960    fn has_element(&mut self) -> Result<bool> {
961        self.de.parser.skip_ws()?;
962
963        match (
964            self.had_comma,
965            !self.de.parser.check_char(self.terminator.as_char()),
966        ) {
967            // Trailing comma, maybe has a next element
968            (true, has_element) => Ok(has_element),
969            // No trailing comma but terminator
970            (false, false) => Ok(false),
971            // No trailing comma or terminator
972            (false, true) => Err(Error::ExpectedComma),
973        }
974    }
975}
976
977enum RangeMapState {
978    StartKey,
979    StartValue,
980    EndKey,
981    EndValue,
982    Done,
983}
984
985struct RangeMapAccess {
986    start: crate::value::Number,
987    end: crate::value::Number,
988    state: RangeMapState,
989    end_key: &'static str,
990}
991
992impl RangeMapAccess {
993    fn new(start: crate::value::Number, end: crate::value::Number, end_key: &'static str) -> Self {
994        RangeMapAccess {
995            start,
996            end,
997            state: RangeMapState::StartKey,
998            end_key,
999        }
1000    }
1001}
1002
1003impl<'de> de::MapAccess<'de> for RangeMapAccess {
1004    type Error = Error;
1005
1006    fn next_key_seed<K: de::DeserializeSeed<'de>>(&mut self, seed: K) -> Result<Option<K::Value>> {
1007        match self.state {
1008            RangeMapState::StartKey => {
1009                self.state = RangeMapState::StartValue;
1010                seed.deserialize(de::value::StrDeserializer::<Error>::new("start"))
1011                    .map(Some)
1012            }
1013            RangeMapState::EndKey => {
1014                self.state = RangeMapState::EndValue;
1015                seed.deserialize(de::value::StrDeserializer::<Error>::new(self.end_key))
1016                    .map(Some)
1017            }
1018            _ => Ok(None),
1019        }
1020    }
1021
1022    fn next_value_seed<V: de::DeserializeSeed<'de>>(&mut self, seed: V) -> Result<V::Value> {
1023        match self.state {
1024            RangeMapState::StartValue => {
1025                self.state = RangeMapState::EndKey;
1026                seed.deserialize(NumberDeserializer(self.start))
1027            }
1028            RangeMapState::EndValue => {
1029                self.state = RangeMapState::Done;
1030                seed.deserialize(NumberDeserializer(self.end))
1031            }
1032            _ => Err(Error::ExpectedDifferentLength {
1033                expected: String::from("map of length 2"),
1034                found: 3,
1035            }),
1036        }
1037    }
1038}
1039
1040struct RangeFromMapAccess {
1041    start: crate::value::Number,
1042    done: bool,
1043}
1044
1045impl RangeFromMapAccess {
1046    fn new(start: crate::value::Number) -> Self {
1047        RangeFromMapAccess { start, done: false }
1048    }
1049}
1050
1051impl<'de> de::MapAccess<'de> for RangeFromMapAccess {
1052    type Error = Error;
1053
1054    fn next_key_seed<K: de::DeserializeSeed<'de>>(&mut self, seed: K) -> Result<Option<K::Value>> {
1055        if self.done {
1056            return Ok(None);
1057        }
1058        seed.deserialize(de::value::StrDeserializer::<Error>::new("start"))
1059            .map(Some)
1060    }
1061
1062    fn next_value_seed<V: de::DeserializeSeed<'de>>(&mut self, seed: V) -> Result<V::Value> {
1063        if self.done {
1064            return Err(Error::ExpectedDifferentLength {
1065                expected: String::from("map of length 1"),
1066                found: 2,
1067            });
1068        }
1069        self.done = true;
1070        seed.deserialize(NumberDeserializer(self.start))
1071    }
1072}
1073
1074struct RangeToMapAccess {
1075    end: crate::value::Number,
1076    end_key: &'static str,
1077    done: bool,
1078}
1079
1080impl RangeToMapAccess {
1081    fn new(end: crate::value::Number, end_key: &'static str) -> Self {
1082        RangeToMapAccess {
1083            end,
1084            end_key,
1085            done: false,
1086        }
1087    }
1088}
1089
1090impl<'de> de::MapAccess<'de> for RangeToMapAccess {
1091    type Error = Error;
1092
1093    fn next_key_seed<K: de::DeserializeSeed<'de>>(&mut self, seed: K) -> Result<Option<K::Value>> {
1094        if self.done {
1095            return Ok(None);
1096        }
1097        seed.deserialize(de::value::StrDeserializer::<Error>::new(self.end_key))
1098            .map(Some)
1099    }
1100
1101    fn next_value_seed<V: de::DeserializeSeed<'de>>(&mut self, seed: V) -> Result<V::Value> {
1102        if self.done {
1103            return Err(Error::ExpectedDifferentLength {
1104                expected: String::from("map of length 1"),
1105                found: 2,
1106            });
1107        }
1108        self.done = true;
1109        seed.deserialize(NumberDeserializer(self.end))
1110    }
1111}
1112
1113impl<'de, 'a> de::SeqAccess<'de> for CommaSeparated<'a, 'de> {
1114    type Error = Error;
1115
1116    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
1117    where
1118        T: DeserializeSeed<'de>,
1119    {
1120        if self.has_element()? {
1121            let res = guard_recursion! { self.de => seed.deserialize(&mut *self.de)? };
1122
1123            self.had_comma = self.de.parser.comma()?;
1124
1125            Ok(Some(res))
1126        } else {
1127            Ok(None)
1128        }
1129    }
1130}
1131
1132impl<'de, 'a> de::MapAccess<'de> for CommaSeparated<'a, 'de> {
1133    type Error = Error;
1134
1135    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
1136    where
1137        K: DeserializeSeed<'de>,
1138    {
1139        if self.has_element()? {
1140            self.inside_internally_tagged_enum = is_serde_tag_or_content::<K::Value>();
1141
1142            match self.terminator {
1143                Terminator::Struct => guard_recursion! { self.de =>
1144                    seed.deserialize(&mut id::Deserializer::new(&mut *self.de, false)).map(Some)
1145                },
1146                Terminator::MapAsStruct => guard_recursion! { self.de =>
1147                    seed.deserialize(&mut id::Deserializer::new(&mut *self.de, true)).map(Some)
1148                },
1149                _ => guard_recursion! { self.de => seed.deserialize(&mut *self.de).map(Some) },
1150            }
1151        } else {
1152            Ok(None)
1153        }
1154    }
1155
1156    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
1157    where
1158        V: DeserializeSeed<'de>,
1159    {
1160        self.de.parser.skip_ws()?;
1161
1162        if self.de.parser.consume_char(':') {
1163            self.de.parser.skip_ws()?;
1164
1165            let res = if self.inside_internally_tagged_enum && !is_serde_content::<V::Value>() {
1166                guard_recursion! { self.de =>
1167                    seed.deserialize(&mut tag::Deserializer::new(&mut *self.de))?
1168                }
1169            } else {
1170                guard_recursion! { self.de =>
1171                    seed.deserialize(&mut *self.de)?
1172                }
1173            };
1174
1175            self.had_comma = self.de.parser.comma()?;
1176
1177            Ok(res)
1178        } else {
1179            Err(Error::ExpectedMapColon)
1180        }
1181    }
1182}
1183
1184struct Enum<'a, 'de: 'a> {
1185    de: &'a mut Deserializer<'de>,
1186}
1187
1188impl<'a, 'de> Enum<'a, 'de> {
1189    fn new(de: &'a mut Deserializer<'de>) -> Self {
1190        Enum { de }
1191    }
1192}
1193
1194impl<'de, 'a> de::EnumAccess<'de> for Enum<'a, 'de> {
1195    type Error = Error;
1196    type Variant = Self;
1197
1198    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant)>
1199    where
1200        V: DeserializeSeed<'de>,
1201    {
1202        self.de.parser.skip_ws()?;
1203
1204        let value = guard_recursion! { self.de => seed.deserialize(&mut *self.de)? };
1205
1206        Ok((value, self))
1207    }
1208}
1209
1210impl<'de, 'a> de::VariantAccess<'de> for Enum<'a, 'de> {
1211    type Error = Error;
1212
1213    fn unit_variant(self) -> Result<()> {
1214        Ok(())
1215    }
1216
1217    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value>
1218    where
1219        T: DeserializeSeed<'de>,
1220    {
1221        let newtype_variant = self.de.last_identifier;
1222
1223        self.de.parser.skip_ws()?;
1224
1225        if self.de.parser.consume_char('(') {
1226            self.de.parser.skip_ws()?;
1227
1228            self.de.newtype_variant = self
1229                .de
1230                .parser
1231                .exts
1232                .contains(Extensions::UNWRAP_VARIANT_NEWTYPES);
1233
1234            let val = guard_recursion! { self.de =>
1235                seed
1236                    .deserialize(&mut *self.de)
1237                    .map_err(|err| struct_error_name(err, newtype_variant))?
1238            };
1239
1240            self.de.newtype_variant = false;
1241
1242            self.de.parser.comma()?;
1243
1244            if self.de.parser.consume_char(')') {
1245                Ok(val)
1246            } else {
1247                Err(Error::ExpectedStructLikeEnd)
1248            }
1249        } else {
1250            Err(Error::ExpectedStructLike)
1251        }
1252    }
1253
1254    fn tuple_variant<V>(self, len: usize, visitor: V) -> Result<V::Value>
1255    where
1256        V: Visitor<'de>,
1257    {
1258        self.de.parser.skip_ws()?;
1259
1260        self.de.deserialize_tuple(len, visitor)
1261    }
1262
1263    fn struct_variant<V>(self, _fields: &'static [&'static str], visitor: V) -> Result<V::Value>
1264    where
1265        V: Visitor<'de>,
1266    {
1267        let struct_variant = self.de.last_identifier;
1268
1269        self.de.parser.skip_ws()?;
1270
1271        self.de
1272            .handle_struct_after_name("", visitor)
1273            .map_err(|err| struct_error_name(err, struct_variant))
1274    }
1275}
1276
1277fn struct_error_name(error: Error, name: Option<&str>) -> Error {
1278    match error {
1279        Error::NoSuchStructField {
1280            expected,
1281            found,
1282            outer: None,
1283        } => Error::NoSuchStructField {
1284            expected,
1285            found,
1286            outer: name.map(ToOwned::to_owned),
1287        },
1288        Error::MissingStructField { field, outer: None } => Error::MissingStructField {
1289            field,
1290            outer: name.map(ToOwned::to_owned),
1291        },
1292        Error::DuplicateStructField { field, outer: None } => Error::DuplicateStructField {
1293            field,
1294            outer: name.map(ToOwned::to_owned),
1295        },
1296        e => e,
1297    }
1298}
1299
1300// Note: OnceLock is only stable with MSRV 1.70 and requires std
1301struct OnceBox<T> {
1302    ptr: core::sync::atomic::AtomicPtr<T>,
1303}
1304
1305impl<T> OnceBox<T> {
1306    const fn new() -> Self {
1307        Self {
1308            ptr: core::sync::atomic::AtomicPtr::new(core::ptr::null_mut()),
1309        }
1310    }
1311
1312    #[allow(unsafe_code)]
1313    fn get_or_init<F>(&self, f: F) -> &T
1314    where
1315        F: FnOnce() -> T,
1316    {
1317        let mut ptr = self.ptr.load(core::sync::atomic::Ordering::Acquire);
1318        if ptr.is_null() {
1319            let val = f();
1320            let new_ptr = alloc::boxed::Box::into_raw(alloc::boxed::Box::new(val));
1321
1322            match self.ptr.compare_exchange(
1323                core::ptr::null_mut(),
1324                new_ptr,
1325                core::sync::atomic::Ordering::AcqRel,
1326                core::sync::atomic::Ordering::Acquire,
1327            ) {
1328                Ok(_) => ptr = new_ptr,
1329                Err(actual) => {
1330                    // SAFETY: `new_ptr` was created via `Box::into_raw` above and lost the CAS race, so it is safe to deallocate.
1331                    unsafe {
1332                        drop(alloc::boxed::Box::from_raw(new_ptr));
1333                    }
1334                    ptr = actual;
1335                }
1336            }
1337        }
1338        // SAFETY: `ptr` points to a valid, leaked `T` stored in the atomic static that lives for `'static`.
1339        unsafe { &*ptr }
1340    }
1341}
1342
1343struct SerdeEnumContent<'a, 'de: 'a> {
1344    de: &'a mut Deserializer<'de>,
1345    ident: Option<&'a str>,
1346}
1347
1348impl<'de, 'a> de::MapAccess<'de> for SerdeEnumContent<'a, 'de> {
1349    type Error = Error;
1350
1351    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
1352    where
1353        K: DeserializeSeed<'de>,
1354    {
1355        self.ident
1356            .take()
1357            .map(|ident| seed.deserialize(de::value::StrDeserializer::new(ident)))
1358            .transpose()
1359    }
1360
1361    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
1362    where
1363        V: DeserializeSeed<'de>,
1364    {
1365        self.de.parser.skip_ws()?;
1366
1367        let old_serde_content_newtype = self.de.serde_content_newtype;
1368        self.de.serde_content_newtype = true;
1369        let result = seed.deserialize(&mut *self.de);
1370        self.de.serde_content_newtype = old_serde_content_newtype;
1371
1372        result
1373    }
1374}
1375
1376fn is_serde_content<T>() -> bool {
1377    #[derive(serde_derive::Deserialize)]
1378    enum A {}
1379    type B = A;
1380
1381    #[derive(serde_derive::Deserialize)]
1382    #[serde(untagged)]
1383    enum UntaggedEnum {
1384        A(A),
1385        B(B),
1386    }
1387
1388    struct TypeIdDeserializer;
1389
1390    impl<'de> de::Deserializer<'de> for TypeIdDeserializer {
1391        type Error = TypeIdError;
1392
1393        fn deserialize_any<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
1394            Err(TypeIdError(typeid::of::<V::Value>()))
1395        }
1396
1397        serde::forward_to_deserialize_any! {
1398            bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
1399            bytes byte_buf option unit unit_struct newtype_struct seq tuple
1400            tuple_struct map struct enum identifier ignored_any
1401        }
1402    }
1403
1404    #[derive(Debug)]
1405    struct TypeIdError(core::any::TypeId);
1406
1407    impl core::fmt::Display for TypeIdError {
1408        fn fmt(&self, _fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
1409            Ok(())
1410        }
1411    }
1412
1413    impl de::Error for TypeIdError {
1414        #[allow(clippy::unreachable)]
1415        fn custom<T: core::fmt::Display>(_msg: T) -> Self {
1416            unreachable!()
1417        }
1418    }
1419
1420    impl de::StdError for TypeIdError {}
1421
1422    fn type_id_of_untagged_enum_default_buffer() -> core::any::TypeId {
1423        static TYPE_ID: OnceBox<core::any::TypeId> = OnceBox::new();
1424
1425        *TYPE_ID.get_or_init(|| match Deserialize::deserialize(TypeIdDeserializer) {
1426            Ok(UntaggedEnum::A(void) | UntaggedEnum::B(void)) => match void {},
1427            Err(TypeIdError(typeid)) => typeid,
1428        })
1429    }
1430
1431    typeid::of::<T>() == type_id_of_untagged_enum_default_buffer()
1432}
1433
1434fn is_serde_tag_or_content<T>() -> bool {
1435    #[derive(serde_derive::Deserialize)]
1436    enum A {}
1437
1438    #[derive(serde_derive::Deserialize)]
1439    #[serde(tag = "tag")]
1440    enum InternallyTaggedEnum {
1441        A { a: A },
1442    }
1443
1444    struct TypeIdDeserializer;
1445
1446    impl<'de> de::Deserializer<'de> for TypeIdDeserializer {
1447        type Error = TypeIdError;
1448
1449        fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
1450        where
1451            V: Visitor<'de>,
1452        {
1453            visitor.visit_map(self)
1454        }
1455
1456        serde::forward_to_deserialize_any! {
1457            bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
1458            bytes byte_buf option unit unit_struct newtype_struct seq tuple
1459            tuple_struct map struct enum identifier ignored_any
1460        }
1461    }
1462
1463    impl<'de> de::MapAccess<'de> for TypeIdDeserializer {
1464        type Error = TypeIdError;
1465
1466        fn next_key_seed<K: DeserializeSeed<'de>>(
1467            &mut self,
1468            _seed: K,
1469        ) -> Result<Option<K::Value>, Self::Error> {
1470            Err(TypeIdError(typeid::of::<K::Value>()))
1471        }
1472
1473        #[allow(clippy::unreachable)]
1474        fn next_value_seed<V: DeserializeSeed<'de>>(
1475            &mut self,
1476            _seed: V,
1477        ) -> Result<V::Value, Self::Error> {
1478            unreachable!()
1479        }
1480    }
1481
1482    #[derive(Debug)]
1483    struct TypeIdError(core::any::TypeId);
1484
1485    impl core::fmt::Display for TypeIdError {
1486        fn fmt(&self, _fmt: &mut core::fmt::Formatter) -> core::fmt::Result {
1487            Ok(())
1488        }
1489    }
1490
1491    impl de::Error for TypeIdError {
1492        #[allow(clippy::unreachable)]
1493        fn custom<T: core::fmt::Display>(_msg: T) -> Self {
1494            unreachable!()
1495        }
1496    }
1497
1498    impl de::StdError for TypeIdError {}
1499
1500    fn type_id_of_internally_tagged_enum_default_tag_or_buffer() -> core::any::TypeId {
1501        static TYPE_ID: OnceBox<core::any::TypeId> = OnceBox::new();
1502
1503        *TYPE_ID.get_or_init(|| match Deserialize::deserialize(TypeIdDeserializer) {
1504            Ok(InternallyTaggedEnum::A { a: void }) => match void {},
1505            Err(TypeIdError(typeid)) => typeid,
1506        })
1507    }
1508
1509    typeid::of::<T>() == type_id_of_internally_tagged_enum_default_tag_or_buffer()
1510}
1511
1512/// Trim the plain (non-comment) whitespace around a `RawValue`, so that
1513/// re-serialising it, e.g. with pretty-printing, does not accumulate whitespace.
1514/// Comments are kept, and whitespace is only trimmed from the end if that does
1515/// not leave an unclosed line comment behind.
1516///
1517/// `src_before` is the source from the start of the whitespace before the value,
1518/// `src_value_end` the source right after the value (before the trailing
1519/// whitespace), and `src_after` the source after the trailing whitespace.
1520fn trim_raw_value_whitespace<'a>(
1521    src_before: &'a str,
1522    src_value_end: &str,
1523    src_after: &str,
1524) -> &'a str {
1525    let start = src_before.len() - src_before.trim_start().len();
1526
1527    let trailing_start = src_before.len() - src_value_end.len();
1528    let trailing = &src_before[trailing_start..src_before.len() - src_after.len()];
1529    let trimmed = trailing.trim_end();
1530    let mut end = trailing_start + trimmed.len();
1531
1532    // Only the (trimmed) trailing whitespace needs to be re-parsed to find out
1533    // if it ends in a line comment that the trimmed whitespace would leave open
1534    if Parser::new(trimmed).map_or(false, |parser| parser.has_unclosed_line_comment()) {
1535        // Keep the whitespace up to and including the line break that closes the comment
1536        let rest = &trailing[trimmed.len()..];
1537        end += rest.find('\n').map_or(rest.len(), |i| i + 1);
1538    }
1539
1540    &src_before[start..end]
1541}
ron/de/mod.rs

ron/de/
mod.rs
