Vendor dependencies for 0.3.0 release

vendor/ron/src/de/id.rs

@@ -0,0 +1,246 @@
+use serde::de::{self, Visitor};
+
+use super::{Deserializer, Error, Result};
+
+pub struct IdDeserializer<'a, 'b: 'a> {
+    d: &'a mut Deserializer<'b>,
+}
+
+impl<'a, 'b: 'a> IdDeserializer<'a, 'b> {
+    pub fn new(d: &'a mut Deserializer<'b>) -> Self {
+        IdDeserializer { d }
+    }
+}
+
+impl<'a, 'b: 'a, 'c> de::Deserializer<'b> for &'c mut IdDeserializer<'a, 'b> {
+    type Error = Error;
+
+    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'b>,
+    {
+        self.d.deserialize_identifier(visitor)
+    }
+
+    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'b>,
+    {
+        self.deserialize_identifier(visitor)
+    }
+
+    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'b>,
+    {
+        self.deserialize_identifier(visitor)
+    }
+
+    fn deserialize_bool<V>(self, _: V) -> Result<V::Value>
+    where
+        V: Visitor<'b>,
+    {
+        Err(Error::ExpectedIdentifier)
+    }
+
+    fn deserialize_i8<V>(self, _: V) -> Result<V::Value>
+    where
+        V: Visitor<'b>,
+    {
+        Err(Error::ExpectedIdentifier)
+    }
+
+    fn deserialize_i16<V>(self, _: V) -> Result<V::Value>
+    where
+        V: Visitor<'b>,
+    {
+        Err(Error::ExpectedIdentifier)
+    }
+
+    fn deserialize_i32<V>(self, _: V) -> Result<V::Value>
+    where
+        V: Visitor<'b>,
+    {
+        Err(Error::ExpectedIdentifier)
+    }
+
+    fn deserialize_i64<V>(self, _: V) -> Result<V::Value>
+    where
+        V: Visitor<'b>,
+    {
+        Err(Error::ExpectedIdentifier)
+    }
+
+    #[cfg(feature = "integer128")]
+    fn deserialize_i128<V>(self, _: V) -> Result<V::Value>
+    where
+        V: Visitor<'b>,
+    {
+        Err(Error::ExpectedIdentifier)
+    }
+
+    fn deserialize_u8<V>(self, _: V) -> Result<V::Value>
+    where
+        V: Visitor<'b>,
+    {
+        Err(Error::ExpectedIdentifier)
+    }
+
+    fn deserialize_u16<V>(self, _: V) -> Result<V::Value>
+    where
+        V: Visitor<'b>,
+    {
+        Err(Error::ExpectedIdentifier)
+    }
+
+    fn deserialize_u32<V>(self, _: V) -> Result<V::Value>
+    where
+        V: Visitor<'b>,
+    {
+        Err(Error::ExpectedIdentifier)
+    }
+
+    fn deserialize_u64<V>(self, _: V) -> Result<V::Value>
+    where
+        V: Visitor<'b>,
+    {
+        Err(Error::ExpectedIdentifier)
+    }
+
+    #[cfg(feature = "integer128")]
+    fn deserialize_u128<V>(self, _: V) -> Result<V::Value>
+    where
+        V: Visitor<'b>,
+    {
+        Err(Error::ExpectedIdentifier)
+    }
+
+    fn deserialize_f32<V>(self, _: V) -> Result<V::Value>
+    where
+        V: Visitor<'b>,
+    {
+        Err(Error::ExpectedIdentifier)
+    }
+
+    fn deserialize_f64<V>(self, _: V) -> Result<V::Value>
+    where
+        V: Visitor<'b>,
+    {
+        Err(Error::ExpectedIdentifier)
+    }
+
+    fn deserialize_char<V>(self, _: V) -> Result<V::Value>
+    where
+        V: Visitor<'b>,
+    {
+        Err(Error::ExpectedIdentifier)
+    }
+
+    fn deserialize_string<V>(self, _: V) -> Result<V::Value>
+    where
+        V: Visitor<'b>,
+    {
+        Err(Error::ExpectedIdentifier)
+    }
+
+    fn deserialize_bytes<V>(self, _: V) -> Result<V::Value>
+    where
+        V: Visitor<'b>,
+    {
+        Err(Error::ExpectedIdentifier)
+    }
+
+    fn deserialize_byte_buf<V>(self, _: V) -> Result<V::Value>
+    where
+        V: Visitor<'b>,
+    {
+        Err(Error::ExpectedIdentifier)
+    }
+
+    fn deserialize_option<V>(self, _: V) -> Result<V::Value>
+    where
+        V: Visitor<'b>,
+    {
+        Err(Error::ExpectedIdentifier)
+    }
+
+    fn deserialize_unit<V>(self, _: V) -> Result<V::Value>
+    where
+        V: Visitor<'b>,
+    {
+        Err(Error::ExpectedIdentifier)
+    }
+
+    fn deserialize_unit_struct<V>(self, _: &'static str, _: V) -> Result<V::Value>
+    where
+        V: Visitor<'b>,
+    {
+        Err(Error::ExpectedIdentifier)
+    }
+
+    fn deserialize_newtype_struct<V>(self, _: &'static str, _: V) -> Result<V::Value>
+    where
+        V: Visitor<'b>,
+    {
+        Err(Error::ExpectedIdentifier)
+    }
+
+    fn deserialize_seq<V>(self, _: V) -> Result<V::Value>
+    where
+        V: Visitor<'b>,
+    {
+        Err(Error::ExpectedIdentifier)
+    }
+
+    fn deserialize_tuple<V>(self, _: usize, _: V) -> Result<V::Value>
+    where
+        V: Visitor<'b>,
+    {
+        Err(Error::ExpectedIdentifier)
+    }
+
+    fn deserialize_tuple_struct<V>(self, _: &'static str, _: usize, _: V) -> Result<V::Value>
+    where
+        V: Visitor<'b>,
+    {
+        Err(Error::ExpectedIdentifier)
+    }
+
+    fn deserialize_map<V>(self, _: V) -> Result<V::Value>
+    where
+        V: Visitor<'b>,
+    {
+        Err(Error::ExpectedIdentifier)
+    }
+
+    fn deserialize_struct<V>(
+        self,
+        _: &'static str,
+        _: &'static [&'static str],
+        _: V,
+    ) -> Result<V::Value>
+    where
+        V: Visitor<'b>,
+    {
+        Err(Error::ExpectedIdentifier)
+    }
+
+    fn deserialize_enum<V>(
+        self,
+        _: &'static str,
+        _: &'static [&'static str],
+        _: V,
+    ) -> Result<V::Value>
+    where
+        V: Visitor<'b>,
+    {
+        Err(Error::ExpectedIdentifier)
+    }
+
+    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'b>,
+    {
+        self.deserialize_any(visitor)
+    }
+}

vendor/ron/src/de/mod.rs

@@ -0,0 +1,869 @@
+/// Deserialization module.
+use std::{borrow::Cow, io, str};
+
+use base64::Engine;
+use serde::{
+    de::{self, DeserializeSeed, Deserializer as _, Visitor},
+    Deserialize,
+};
+
+use self::{id::IdDeserializer, tag::TagDeserializer};
+pub use crate::error::{Error, Position, SpannedError};
+use crate::{
+    error::{Result, SpannedResult},
+    extensions::Extensions,
+    options::Options,
+    parse::{AnyNum, Bytes, ParsedStr, BASE64_ENGINE},
+};
+
+mod id;
+mod tag;
+#[cfg(test)]
+mod tests;
+mod value;
+
+/// The RON deserializer.
+///
+/// If you just want to simply deserialize a value,
+/// you can use the [`from_str`] convenience function.
+pub struct Deserializer<'de> {
+    bytes: Bytes<'de>,
+    newtype_variant: bool,
+    last_identifier: Option<&'de str>,
+    recursion_limit: Option<usize>,
+}
+
+impl<'de> Deserializer<'de> {
+    // Cannot implement trait here since output is tied to input lifetime 'de.
+    #[allow(clippy::should_implement_trait)]
+    pub fn from_str(input: &'de str) -> SpannedResult<Self> {
+        Self::from_str_with_options(input, Options::default())
+    }
+
+    pub fn from_bytes(input: &'de [u8]) -> SpannedResult<Self> {
+        Self::from_bytes_with_options(input, Options::default())
+    }
+
+    pub fn from_str_with_options(input: &'de str, options: Options) -> SpannedResult<Self> {
+        Self::from_bytes_with_options(input.as_bytes(), options)
+    }
+
+    pub fn from_bytes_with_options(input: &'de [u8], options: Options) -> SpannedResult<Self> {
+        let mut deserializer = Deserializer {
+            bytes: Bytes::new(input)?,
+            newtype_variant: false,
+            last_identifier: None,
+            recursion_limit: options.recursion_limit,
+        };
+
+        deserializer.bytes.exts |= options.default_extensions;
+
+        Ok(deserializer)
+    }
+
+    pub fn remainder(&self) -> Cow<'_, str> {
+        String::from_utf8_lossy(self.bytes.bytes())
+    }
+
+    pub fn span_error(&self, code: Error) -> SpannedError {
+        self.bytes.span_error(code)
+    }
+}
+
+/// A convenience function for building a deserializer
+/// and deserializing a value of type `T` from a reader.
+pub fn from_reader<R, T>(rdr: R) -> SpannedResult<T>
+where
+    R: io::Read,
+    T: de::DeserializeOwned,
+{
+    Options::default().from_reader(rdr)
+}
+
+/// A convenience function for building a deserializer
+/// and deserializing a value of type `T` from a string.
+pub fn from_str<'a, T>(s: &'a str) -> SpannedResult<T>
+where
+    T: de::Deserialize<'a>,
+{
+    Options::default().from_str(s)
+}
+
+/// A convenience function for building a deserializer
+/// and deserializing a value of type `T` from bytes.
+pub fn from_bytes<'a, T>(s: &'a [u8]) -> SpannedResult<T>
+where
+    T: de::Deserialize<'a>,
+{
+    Options::default().from_bytes(s)
+}
+
+macro_rules! guard_recursion {
+    ($self:expr => $expr:expr) => {{
+        if let Some(limit) = &mut $self.recursion_limit {
+            if let Some(new_limit) = limit.checked_sub(1) {
+                *limit = new_limit;
+            } else {
+                return Err(Error::ExceededRecursionLimit);
+            }
+        }
+
+        let result = $expr;
+
+        if let Some(limit) = &mut $self.recursion_limit {
+            *limit = limit.saturating_add(1);
+        }
+
+        result
+    }};
+}
+
+impl<'de> Deserializer<'de> {
+    /// Check if the remaining bytes are whitespace only,
+    /// otherwise return an error.
+    pub fn end(&mut self) -> Result<()> {
+        self.bytes.skip_ws()?;
+
+        if self.bytes.bytes().is_empty() {
+            Ok(())
+        } else {
+            Err(Error::TrailingCharacters)
+        }
+    }
+
+    /// Called from [`deserialize_any`][serde::Deserializer::deserialize_any]
+    /// when a struct was detected. Decides if there is a unit, tuple or usual
+    /// struct and deserializes it accordingly.
+    ///
+    /// This method assumes there is no identifier left.
+    fn handle_any_struct<V>(&mut self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        // Create a working copy
+        let mut bytes = self.bytes;
+
+        if bytes.consume("(") {
+            bytes.skip_ws()?;
+
+            if bytes.check_tuple_struct()? {
+                // first argument is technically incorrect, but ignored anyway
+                self.deserialize_tuple(0, visitor)
+            } else {
+                // giving no name results in worse errors but is necessary here
+                self.handle_struct_after_name("", visitor)
+            }
+        } else {
+            visitor.visit_unit()
+        }
+    }
+
+    /// Called from
+    /// [`deserialize_struct`][serde::Deserializer::deserialize_struct],
+    /// [`struct_variant`][serde::de::VariantAccess::struct_variant], and
+    /// [`handle_any_struct`][Self::handle_any_struct]. Handles
+    /// deserialising the enclosing parentheses and everything in between.
+    ///
+    /// This method assumes there is no struct name identifier left.
+    fn handle_struct_after_name<V>(
+        &mut self,
+        name_for_pretty_errors_only: &'static str,
+        visitor: V,
+    ) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        if self.newtype_variant || self.bytes.consume("(") {
+            let old_newtype_variant = self.newtype_variant;
+            self.newtype_variant = false;
+
+            let value = guard_recursion! { self =>
+                visitor
+                    .visit_map(CommaSeparated::new(b')', self))
+                    .map_err(|err| {
+                        struct_error_name(
+                            err,
+                            if !old_newtype_variant && !name_for_pretty_errors_only.is_empty() {
+                                Some(name_for_pretty_errors_only)
+                            } else {
+                                None
+                            },
+                        )
+                    })?
+            };
+
+            self.bytes.skip_ws()?;
+
+            if old_newtype_variant || self.bytes.consume(")") {
+                Ok(value)
+            } else {
+                Err(Error::ExpectedStructLikeEnd)
+            }
+        } else if name_for_pretty_errors_only.is_empty() {
+            Err(Error::ExpectedStructLike)
+        } else {
+            Err(Error::ExpectedNamedStructLike(name_for_pretty_errors_only))
+        }
+    }
+}
+
+impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
+    type Error = Error;
+
+    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        // Newtype variants can only be unwrapped if we receive information
+        //  about the wrapped type - with `deserialize_any` we don't
+        self.newtype_variant = false;
+
+        if self.bytes.consume_ident("true") {
+            return visitor.visit_bool(true);
+        } else if self.bytes.consume_ident("false") {
+            return visitor.visit_bool(false);
+        } else if self.bytes.check_ident("Some") {
+            return self.deserialize_option(visitor);
+        } else if self.bytes.consume_ident("None") {
+            return visitor.visit_none();
+        } else if self.bytes.consume("()") {
+            return visitor.visit_unit();
+        } else if self.bytes.consume_ident("inf") {
+            return visitor.visit_f64(std::f64::INFINITY);
+        } else if self.bytes.consume_ident("-inf") {
+            return visitor.visit_f64(std::f64::NEG_INFINITY);
+        } else if self.bytes.consume_ident("NaN") {
+            return visitor.visit_f64(std::f64::NAN);
+        }
+
+        // `identifier` does not change state if it fails
+        let ident = self.bytes.identifier().ok();
+
+        if ident.is_some() {
+            self.bytes.skip_ws()?;
+
+            return self.handle_any_struct(visitor);
+        }
+
+        match self.bytes.peek_or_eof()? {
+            b'(' => self.handle_any_struct(visitor),
+            b'[' => self.deserialize_seq(visitor),
+            b'{' => self.deserialize_map(visitor),
+            b'0'..=b'9' | b'+' | b'-' => {
+                let any_num: AnyNum = self.bytes.any_num()?;
+
+                match any_num {
+                    AnyNum::F32(x) => visitor.visit_f32(x),
+                    AnyNum::F64(x) => visitor.visit_f64(x),
+                    AnyNum::I8(x) => visitor.visit_i8(x),
+                    AnyNum::U8(x) => visitor.visit_u8(x),
+                    AnyNum::I16(x) => visitor.visit_i16(x),
+                    AnyNum::U16(x) => visitor.visit_u16(x),
+                    AnyNum::I32(x) => visitor.visit_i32(x),
+                    AnyNum::U32(x) => visitor.visit_u32(x),
+                    AnyNum::I64(x) => visitor.visit_i64(x),
+                    AnyNum::U64(x) => visitor.visit_u64(x),
+                    #[cfg(feature = "integer128")]
+                    AnyNum::I128(x) => visitor.visit_i128(x),
+                    #[cfg(feature = "integer128")]
+                    AnyNum::U128(x) => visitor.visit_u128(x),
+                }
+            }
+            b'.' => self.deserialize_f64(visitor),
+            b'"' | b'r' => self.deserialize_string(visitor),
+            b'\'' => self.deserialize_char(visitor),
+            other => Err(Error::UnexpectedByte(other as char)),
+        }
+    }
+
+    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_bool(self.bytes.bool()?)
+    }
+
+    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_i8(self.bytes.signed_integer()?)
+    }
+
+    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_i16(self.bytes.signed_integer()?)
+    }
+
+    fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_i32(self.bytes.signed_integer()?)
+    }
+
+    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_i64(self.bytes.signed_integer()?)
+    }
+
+    #[cfg(feature = "integer128")]
+    fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_i128(self.bytes.signed_integer()?)
+    }
+
+    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_u8(self.bytes.unsigned_integer()?)
+    }
+
+    fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_u16(self.bytes.unsigned_integer()?)
+    }
+
+    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_u32(self.bytes.unsigned_integer()?)
+    }
+
+    fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_u64(self.bytes.unsigned_integer()?)
+    }
+
+    #[cfg(feature = "integer128")]
+    fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_u128(self.bytes.unsigned_integer()?)
+    }
+
+    fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_f32(self.bytes.float()?)
+    }
+
+    fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_f64(self.bytes.float()?)
+    }
+
+    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_char(self.bytes.char()?)
+    }
+
+    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        match self.bytes.string()? {
+            ParsedStr::Allocated(s) => visitor.visit_string(s),
+            ParsedStr::Slice(s) => visitor.visit_borrowed_str(s),
+        }
+    }
+
+    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.deserialize_str(visitor)
+    }
+
+    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.deserialize_byte_buf(visitor)
+    }
+
+    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        if let Some(b'[') = self.bytes.peek() {
+            let bytes = Vec::<u8>::deserialize(self)?;
+            return visitor.visit_byte_buf(bytes);
+        }
+
+        let res = {
+            let string = self.bytes.string()?;
+            let base64_str = match string {
+                ParsedStr::Allocated(ref s) => s.as_str(),
+                ParsedStr::Slice(s) => s,
+            };
+            BASE64_ENGINE.decode(base64_str)
+        };
+
+        match res {
+            Ok(byte_buf) => visitor.visit_byte_buf(byte_buf),
+            Err(err) => Err(Error::Base64Error(err)),
+        }
+    }
+
+    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        if self.bytes.consume("None") {
+            visitor.visit_none()
+        } else if self.bytes.consume("Some") && {
+            self.bytes.skip_ws()?;
+            self.bytes.consume("(")
+        } {
+            self.bytes.skip_ws()?;
+
+            let v = guard_recursion! { self => visitor.visit_some(&mut *self)? };
+
+            self.bytes.comma()?;
+
+            if self.bytes.consume(")") {
+                Ok(v)
+            } else {
+                Err(Error::ExpectedOptionEnd)
+            }
+        } else if self.bytes.exts.contains(Extensions::IMPLICIT_SOME) {
+            guard_recursion! { self => visitor.visit_some(&mut *self) }
+        } else {
+            Err(Error::ExpectedOption)
+        }
+    }
+
+    // In Serde, unit means an anonymous value containing no data.
+    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        if self.newtype_variant || self.bytes.consume("()") {
+            self.newtype_variant = false;
+
+            visitor.visit_unit()
+        } else {
+            Err(Error::ExpectedUnit)
+        }
+    }
+
+    fn deserialize_unit_struct<V>(self, name: &'static str, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        if self.newtype_variant || self.bytes.consume_struct_name(name)? {
+            self.newtype_variant = false;
+
+            visitor.visit_unit()
+        } else {
+            self.deserialize_unit(visitor)
+        }
+    }
+
+    fn deserialize_newtype_struct<V>(self, name: &'static str, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        if self.bytes.exts.contains(Extensions::UNWRAP_NEWTYPES) || self.newtype_variant {
+            self.newtype_variant = false;
+
+            return guard_recursion! { self => visitor.visit_newtype_struct(&mut *self) };
+        }
+
+        self.bytes.consume_struct_name(name)?;
+
+        self.bytes.skip_ws()?;
+
+        if self.bytes.consume("(") {
+            self.bytes.skip_ws()?;
+            let value = guard_recursion! { self => visitor.visit_newtype_struct(&mut *self)? };
+            self.bytes.comma()?;
+
+            if self.bytes.consume(")") {
+                Ok(value)
+            } else {
+                Err(Error::ExpectedStructLikeEnd)
+            }
+        } else if name.is_empty() {
+            Err(Error::ExpectedStructLike)
+        } else {
+            Err(Error::ExpectedNamedStructLike(name))
+        }
+    }
+
+    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.newtype_variant = false;
+
+        if self.bytes.consume("[") {
+            let value = guard_recursion! { self =>
+                visitor.visit_seq(CommaSeparated::new(b']', self))?
+            };
+            self.bytes.skip_ws()?;
+
+            if self.bytes.consume("]") {
+                Ok(value)
+            } else {
+                Err(Error::ExpectedArrayEnd)
+            }
+        } else {
+            Err(Error::ExpectedArray)
+        }
+    }
+
+    fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        if self.newtype_variant || self.bytes.consume("(") {
+            let old_newtype_variant = self.newtype_variant;
+            self.newtype_variant = false;
+
+            let value = guard_recursion! { self =>
+                visitor.visit_seq(CommaSeparated::new(b')', self))?
+            };
+            self.bytes.skip_ws()?;
+
+            if old_newtype_variant || self.bytes.consume(")") {
+                Ok(value)
+            } else {
+                Err(Error::ExpectedStructLikeEnd)
+            }
+        } else {
+            Err(Error::ExpectedStructLike)
+        }
+    }
+
+    fn deserialize_tuple_struct<V>(
+        self,
+        name: &'static str,
+        len: usize,
+        visitor: V,
+    ) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        if !self.newtype_variant {
+            self.bytes.consume_struct_name(name)?;
+        }
+
+        self.deserialize_tuple(len, visitor).map_err(|e| match e {
+            Error::ExpectedStructLike if !name.is_empty() => Error::ExpectedNamedStructLike(name),
+            e => e,
+        })
+    }
+
+    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.newtype_variant = false;
+
+        if self.bytes.consume("{") {
+            let value = guard_recursion! { self =>
+                visitor.visit_map(CommaSeparated::new(b'}', self))?
+            };
+            self.bytes.skip_ws()?;
+
+            if self.bytes.consume("}") {
+                Ok(value)
+            } else {
+                Err(Error::ExpectedMapEnd)
+            }
+        } else {
+            Err(Error::ExpectedMap)
+        }
+    }
+
+    fn deserialize_struct<V>(
+        self,
+        name: &'static str,
+        _fields: &'static [&'static str],
+        visitor: V,
+    ) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        if !self.newtype_variant {
+            self.bytes.consume_struct_name(name)?;
+        }
+
+        self.bytes.skip_ws()?;
+
+        self.handle_struct_after_name(name, visitor)
+    }
+
+    fn deserialize_enum<V>(
+        self,
+        name: &'static str,
+        _variants: &'static [&'static str],
+        visitor: V,
+    ) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.newtype_variant = false;
+
+        match guard_recursion! { self => visitor.visit_enum(Enum::new(self)) } {
+            Ok(value) => Ok(value),
+            Err(Error::NoSuchEnumVariant {
+                expected,
+                found,
+                outer: None,
+            }) if !name.is_empty() => Err(Error::NoSuchEnumVariant {
+                expected,
+                found,
+                outer: Some(String::from(name)),
+            }),
+            Err(e) => Err(e),
+        }
+    }
+
+    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        let identifier = str::from_utf8(self.bytes.identifier()?).map_err(Error::from)?;
+
+        self.last_identifier = Some(identifier);
+
+        visitor.visit_borrowed_str(identifier)
+    }
+
+    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.deserialize_any(visitor)
+    }
+}
+
+struct CommaSeparated<'a, 'de: 'a> {
+    de: &'a mut Deserializer<'de>,
+    terminator: u8,
+    had_comma: bool,
+}
+
+impl<'a, 'de> CommaSeparated<'a, 'de> {
+    fn new(terminator: u8, de: &'a mut Deserializer<'de>) -> Self {
+        CommaSeparated {
+            de,
+            terminator,
+            had_comma: true,
+        }
+    }
+
+    fn has_element(&mut self) -> Result<bool> {
+        self.de.bytes.skip_ws()?;
+
+        match (
+            self.had_comma,
+            self.de.bytes.peek_or_eof()? != self.terminator,
+        ) {
+            // Trailing comma, maybe has a next element
+            (true, has_element) => Ok(has_element),
+            // No trailing comma but terminator
+            (false, false) => Ok(false),
+            // No trailing comma or terminator
+            (false, true) => Err(Error::ExpectedComma),
+        }
+    }
+}
+
+impl<'de, 'a> de::SeqAccess<'de> for CommaSeparated<'a, 'de> {
+    type Error = Error;
+
+    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
+    where
+        T: DeserializeSeed<'de>,
+    {
+        if self.has_element()? {
+            let res = guard_recursion! { self.de => seed.deserialize(&mut *self.de)? };
+
+            self.had_comma = self.de.bytes.comma()?;
+
+            Ok(Some(res))
+        } else {
+            Ok(None)
+        }
+    }
+}
+
+impl<'de, 'a> de::MapAccess<'de> for CommaSeparated<'a, 'de> {
+    type Error = Error;
+
+    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
+    where
+        K: DeserializeSeed<'de>,
+    {
+        if self.has_element()? {
+            if self.terminator == b')' {
+                guard_recursion! { self.de =>
+                    seed.deserialize(&mut IdDeserializer::new(&mut *self.de)).map(Some)
+                }
+            } else {
+                guard_recursion! { self.de => seed.deserialize(&mut *self.de).map(Some) }
+            }
+        } else {
+            Ok(None)
+        }
+    }
+
+    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
+    where
+        V: DeserializeSeed<'de>,
+    {
+        self.de.bytes.skip_ws()?;
+
+        if self.de.bytes.consume(":") {
+            self.de.bytes.skip_ws()?;
+
+            let res = guard_recursion! { self.de =>
+                seed.deserialize(&mut TagDeserializer::new(&mut *self.de))?
+            };
+
+            self.had_comma = self.de.bytes.comma()?;
+
+            Ok(res)
+        } else {
+            Err(Error::ExpectedMapColon)
+        }
+    }
+}
+
+struct Enum<'a, 'de: 'a> {
+    de: &'a mut Deserializer<'de>,
+}
+
+impl<'a, 'de> Enum<'a, 'de> {
+    fn new(de: &'a mut Deserializer<'de>) -> Self {
+        Enum { de }
+    }
+}
+
+impl<'de, 'a> de::EnumAccess<'de> for Enum<'a, 'de> {
+    type Error = Error;
+    type Variant = Self;
+
+    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant)>
+    where
+        V: DeserializeSeed<'de>,
+    {
+        self.de.bytes.skip_ws()?;
+
+        let value = guard_recursion! { self.de => seed.deserialize(&mut *self.de)? };
+
+        Ok((value, self))
+    }
+}
+
+impl<'de, 'a> de::VariantAccess<'de> for Enum<'a, 'de> {
+    type Error = Error;
+
+    fn unit_variant(self) -> Result<()> {
+        Ok(())
+    }
+
+    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value>
+    where
+        T: DeserializeSeed<'de>,
+    {
+        let newtype_variant = self.de.last_identifier;
+
+        self.de.bytes.skip_ws()?;
+
+        if self.de.bytes.consume("(") {
+            self.de.bytes.skip_ws()?;
+
+            self.de.newtype_variant = self
+                .de
+                .bytes
+                .exts
+                .contains(Extensions::UNWRAP_VARIANT_NEWTYPES);
+
+            let val = guard_recursion! { self.de =>
+                seed
+                    .deserialize(&mut *self.de)
+                    .map_err(|err| struct_error_name(err, newtype_variant))?
+            };
+
+            self.de.newtype_variant = false;
+
+            self.de.bytes.comma()?;
+
+            if self.de.bytes.consume(")") {
+                Ok(val)
+            } else {
+                Err(Error::ExpectedStructLikeEnd)
+            }
+        } else {
+            Err(Error::ExpectedStructLike)
+        }
+    }
+
+    fn tuple_variant<V>(self, len: usize, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.de.bytes.skip_ws()?;
+
+        self.de.deserialize_tuple(len, visitor)
+    }
+
+    fn struct_variant<V>(self, _fields: &'static [&'static str], visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        let struct_variant = self.de.last_identifier;
+
+        self.de.bytes.skip_ws()?;
+
+        self.de
+            .handle_struct_after_name("", visitor)
+            .map_err(|err| struct_error_name(err, struct_variant))
+    }
+}
+
+fn struct_error_name(error: Error, name: Option<&str>) -> Error {
+    match error {
+        Error::NoSuchStructField {
+            expected,
+            found,
+            outer: None,
+        } => Error::NoSuchStructField {
+            expected,
+            found,
+            outer: name.map(ToOwned::to_owned),
+        },
+        Error::MissingStructField { field, outer: None } => Error::MissingStructField {
+            field,
+            outer: name.map(ToOwned::to_owned),
+        },
+        Error::DuplicateStructField { field, outer: None } => Error::DuplicateStructField {
+            field,
+            outer: name.map(ToOwned::to_owned),
+        },
+        e => e,
+    }
+}

vendor/ron/src/de/tag.rs

@@ -0,0 +1,251 @@
+use serde::de::{self, Visitor};
+
+use super::{Deserializer, Error, Result};
+
+pub struct TagDeserializer<'a, 'b: 'a> {
+    d: &'a mut Deserializer<'b>,
+}
+
+impl<'a, 'b: 'a> TagDeserializer<'a, 'b> {
+    pub fn new(d: &'a mut Deserializer<'b>) -> Self {
+        TagDeserializer { d }
+    }
+}
+
+impl<'a, 'b: 'a, 'c> de::Deserializer<'b> for &'c mut TagDeserializer<'a, 'b> {
+    type Error = Error;
+
+    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'b>,
+    {
+        self.d.deserialize_str(visitor)
+    }
+
+    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'b>,
+    {
+        self.deserialize_str(visitor)
+    }
+
+    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'b>,
+    {
+        self.d.deserialize_any(visitor)
+    }
+
+    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'b>,
+    {
+        self.d.deserialize_bool(visitor)
+    }
+
+    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'b>,
+    {
+        self.d.deserialize_i8(visitor)
+    }
+
+    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'b>,
+    {
+        self.d.deserialize_i16(visitor)
+    }
+
+    fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'b>,
+    {
+        self.d.deserialize_i32(visitor)
+    }
+
+    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'b>,
+    {
+        self.d.deserialize_i64(visitor)
+    }
+
+    #[cfg(feature = "integer128")]
+    fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'b>,
+    {
+        self.d.deserialize_i128(visitor)
+    }
+
+    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'b>,
+    {
+        self.d.deserialize_u8(visitor)
+    }
+
+    fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'b>,
+    {
+        self.d.deserialize_u16(visitor)
+    }
+
+    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'b>,
+    {
+        self.d.deserialize_u32(visitor)
+    }
+
+    fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'b>,
+    {
+        self.d.deserialize_u64(visitor)
+    }
+
+    #[cfg(feature = "integer128")]
+    fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'b>,
+    {
+        self.d.deserialize_u128(visitor)
+    }
+
+    fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'b>,
+    {
+        self.d.deserialize_f32(visitor)
+    }
+
+    fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'b>,
+    {
+        self.d.deserialize_f64(visitor)
+    }
+
+    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'b>,
+    {
+        self.d.deserialize_char(visitor)
+    }
+
+    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'b>,
+    {
+        self.d.deserialize_string(visitor)
+    }
+
+    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'b>,
+    {
+        self.d.deserialize_bytes(visitor)
+    }
+
+    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'b>,
+    {
+        self.d.deserialize_byte_buf(visitor)
+    }
+
+    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'b>,
+    {
+        self.d.deserialize_option(visitor)
+    }
+
+    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'b>,
+    {
+        self.d.deserialize_unit(visitor)
+    }
+
+    fn deserialize_unit_struct<V>(self, name: &'static str, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'b>,
+    {
+        self.d.deserialize_unit_struct(name, visitor)
+    }
+
+    fn deserialize_newtype_struct<V>(self, name: &'static str, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'b>,
+    {
+        self.d.deserialize_newtype_struct(name, visitor)
+    }
+
+    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'b>,
+    {
+        self.d.deserialize_seq(visitor)
+    }
+
+    fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'b>,
+    {
+        self.d.deserialize_tuple(len, visitor)
+    }
+
+    fn deserialize_tuple_struct<V>(
+        self,
+        name: &'static str,
+        len: usize,
+        visitor: V,
+    ) -> Result<V::Value>
+    where
+        V: Visitor<'b>,
+    {
+        self.d.deserialize_tuple_struct(name, len, visitor)
+    }
+
+    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'b>,
+    {
+        self.d.deserialize_map(visitor)
+    }
+
+    fn deserialize_struct<V>(
+        self,
+        name: &'static str,
+        fields: &'static [&'static str],
+        visitor: V,
+    ) -> Result<V::Value>
+    where
+        V: Visitor<'b>,
+    {
+        self.d.deserialize_struct(name, fields, visitor)
+    }
+
+    fn deserialize_enum<V>(
+        self,
+        name: &'static str,
+        variants: &'static [&'static str],
+        visitor: V,
+    ) -> Result<V::Value>
+    where
+        V: Visitor<'b>,
+    {
+        self.d.deserialize_enum(name, variants, visitor)
+    }
+
+    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'b>,
+    {
+        self.d.deserialize_ignored_any(visitor)
+    }
+}

vendor/ron/src/de/tests.rs

@@ -0,0 +1,363 @@
+use serde_bytes;
+use serde_derive::Deserialize;
+
+use crate::{
+    de::from_str,
+    error::{Error, Position, SpannedError, SpannedResult},
+    parse::{AnyNum, Bytes},
+};
+
+#[derive(Debug, PartialEq, Deserialize)]
+struct EmptyStruct1;
+
+#[derive(Debug, PartialEq, Deserialize)]
+struct EmptyStruct2 {}
+
+#[derive(Clone, Copy, Debug, PartialEq, Deserialize)]
+struct MyStruct {
+    x: f32,
+    y: f32,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Deserialize)]
+enum MyEnum {
+    A,
+    B(bool),
+    C(bool, f32),
+    D { a: i32, b: i32 },
+}
+
+#[derive(Debug, Deserialize, PartialEq)]
+struct BytesStruct {
+    small: Vec<u8>,
+    #[serde(with = "serde_bytes")]
+    large: Vec<u8>,
+}
+
+#[test]
+fn test_empty_struct() {
+    assert_eq!(Ok(EmptyStruct1), from_str("EmptyStruct1"));
+    assert_eq!(Ok(EmptyStruct2 {}), from_str("EmptyStruct2()"));
+}
+
+#[test]
+fn test_struct() {
+    let my_struct = MyStruct { x: 4.0, y: 7.0 };
+
+    assert_eq!(Ok(my_struct), from_str("MyStruct(x:4,y:7,)"));
+    assert_eq!(Ok(my_struct), from_str("(x:4,y:7)"));
+
+    #[derive(Debug, PartialEq, Deserialize)]
+    struct NewType(i32);
+
+    assert_eq!(Ok(NewType(42)), from_str("NewType(42)"));
+    assert_eq!(Ok(NewType(33)), from_str("(33)"));
+
+    #[derive(Debug, PartialEq, Deserialize)]
+    struct TupleStruct(f32, f32);
+
+    assert_eq!(Ok(TupleStruct(2.0, 5.0)), from_str("TupleStruct(2,5,)"));
+    assert_eq!(Ok(TupleStruct(3.0, 4.0)), from_str("(3,4)"));
+}
+
+#[test]
+fn test_option() {
+    assert_eq!(Ok(Some(1u8)), from_str("Some(1)"));
+    assert_eq!(Ok(None::<u8>), from_str("None"));
+}
+
+#[test]
+fn test_enum() {
+    assert_eq!(Ok(MyEnum::A), from_str("A"));
+    assert_eq!(Ok(MyEnum::B(true)), from_str("B(true,)"));
+    assert_eq!(Ok(MyEnum::C(true, 3.5)), from_str("C(true,3.5,)"));
+    assert_eq!(Ok(MyEnum::D { a: 2, b: 3 }), from_str("D(a:2,b:3,)"));
+}
+
+#[test]
+fn test_array() {
+    let empty: [i32; 0] = [];
+    assert_eq!(Ok(empty), from_str("()"));
+    let empty_array = empty.to_vec();
+    assert_eq!(Ok(empty_array), from_str("[]"));
+
+    assert_eq!(Ok([2, 3, 4i32]), from_str("(2,3,4,)"));
+    assert_eq!(Ok([2, 3, 4i32].to_vec()), from_str("[2,3,4,]"));
+}
+
+#[test]
+fn test_map() {
+    use std::collections::HashMap;
+
+    let mut map = HashMap::new();
+    map.insert((true, false), 4);
+    map.insert((false, false), 123);
+
+    assert_eq!(
+        Ok(map),
+        from_str(
+            "{
+        (true,false,):4,
+        (false,false,):123,
+    }"
+        )
+    );
+}
+
+#[test]
+fn test_string() {
+    let s: String = from_str("\"String\"").unwrap();
+    assert_eq!("String", s);
+
+    let raw: String = from_str("r\"String\"").unwrap();
+    assert_eq!("String", raw);
+
+    let raw_hashes: String = from_str("r#\"String\"#").unwrap();
+    assert_eq!("String", raw_hashes);
+
+    let raw_hashes_multiline: String = from_str("r#\"String with\nmultiple\nlines\n\"#").unwrap();
+    assert_eq!("String with\nmultiple\nlines\n", raw_hashes_multiline);
+
+    let raw_hashes_quote: String = from_str("r##\"String with \"#\"##").unwrap();
+    assert_eq!("String with \"#", raw_hashes_quote);
+}
+
+#[test]
+fn test_char() {
+    assert_eq!(Ok('c'), from_str("'c'"));
+}
+
+#[test]
+fn test_escape_char() {
+    assert_eq!('\'', from_str::<char>("'\\''").unwrap());
+}
+
+#[test]
+fn test_escape() {
+    assert_eq!("\"Quoted\"", from_str::<String>(r#""\"Quoted\"""#).unwrap());
+}
+
+#[test]
+fn test_comment() {
+    assert_eq!(
+        MyStruct { x: 1.0, y: 2.0 },
+        from_str(
+            "(
+x: 1.0, // x is just 1
+// There is another comment in the very next line..
+// And y is indeed
+y: 2.0 // 2!
+    )"
+        )
+        .unwrap()
+    );
+}
+
+fn err<T>(kind: Error, line: usize, col: usize) -> SpannedResult<T> {
+    Err(SpannedError {
+        code: kind,
+        position: Position { line, col },
+    })
+}
+
+#[test]
+fn test_err_wrong_value() {
+    use std::collections::HashMap;
+
+    use self::Error::*;
+
+    assert_eq!(from_str::<f32>("'c'"), err(ExpectedFloat, 1, 1));
+    assert_eq!(from_str::<String>("'c'"), err(ExpectedString, 1, 1));
+    assert_eq!(from_str::<HashMap<u32, u32>>("'c'"), err(ExpectedMap, 1, 1));
+    assert_eq!(from_str::<[u8; 5]>("'c'"), err(ExpectedStructLike, 1, 1));
+    assert_eq!(from_str::<Vec<u32>>("'c'"), err(ExpectedArray, 1, 1));
+    assert_eq!(from_str::<MyEnum>("'c'"), err(ExpectedIdentifier, 1, 1));
+    assert_eq!(
+        from_str::<MyStruct>("'c'"),
+        err(ExpectedNamedStructLike("MyStruct"), 1, 1)
+    );
+    assert_eq!(
+        from_str::<MyStruct>("NotMyStruct(x: 4, y: 2)"),
+        err(
+            ExpectedDifferentStructName {
+                expected: "MyStruct",
+                found: String::from("NotMyStruct")
+            },
+            1,
+            12
+        )
+    );
+    assert_eq!(from_str::<(u8, bool)>("'c'"), err(ExpectedStructLike, 1, 1));
+    assert_eq!(from_str::<bool>("notabool"), err(ExpectedBoolean, 1, 1));
+
+    assert_eq!(
+        from_str::<MyStruct>("MyStruct(\n    x: true)"),
+        err(ExpectedFloat, 2, 8)
+    );
+    assert_eq!(
+        from_str::<MyStruct>("MyStruct(\n    x: 3.5, \n    y:)"),
+        err(ExpectedFloat, 3, 7)
+    );
+}
+
+#[test]
+fn test_perm_ws() {
+    assert_eq!(
+        from_str::<MyStruct>("\nMyStruct  \t ( \n x   : 3.5 , \t y\n: 4.5 \n ) \t\n"),
+        Ok(MyStruct { x: 3.5, y: 4.5 })
+    );
+}
+
+#[test]
+fn untagged() {
+    #[derive(Deserialize, Debug, PartialEq)]
+    #[serde(untagged)]
+    enum Untagged {
+        U8(u8),
+        Bool(bool),
+    }
+
+    assert_eq!(from_str::<Untagged>("true").unwrap(), Untagged::Bool(true));
+    assert_eq!(from_str::<Untagged>("8").unwrap(), Untagged::U8(8));
+}
+
+#[test]
+fn rename() {
+    #[derive(Deserialize, Debug, PartialEq)]
+    enum Foo {
+        #[serde(rename = "2d")]
+        D2,
+        #[serde(rename = "triangle-list")]
+        TriangleList,
+    }
+    assert_eq!(from_str::<Foo>("r#2d").unwrap(), Foo::D2);
+    assert_eq!(
+        from_str::<Foo>("r#triangle-list").unwrap(),
+        Foo::TriangleList
+    );
+}
+
+#[test]
+fn forgot_apostrophes() {
+    let de: SpannedResult<(i32, String)> = from_str("(4, \"Hello)");
+
+    assert!(matches!(
+        de,
+        Err(SpannedError {
+            code: Error::ExpectedStringEnd,
+            position: _,
+        })
+    ));
+}
+
+#[test]
+fn expected_attribute() {
+    let de: SpannedResult<String> = from_str("#\"Hello\"");
+
+    assert_eq!(de, err(Error::ExpectedAttribute, 1, 2));
+}
+
+#[test]
+fn expected_attribute_end() {
+    let de: SpannedResult<String> = from_str("#![enable(unwrap_newtypes) \"Hello\"");
+
+    assert_eq!(de, err(Error::ExpectedAttributeEnd, 1, 28));
+}
+
+#[test]
+fn invalid_attribute() {
+    let de: SpannedResult<String> = from_str("#![enable(invalid)] \"Hello\"");
+
+    assert_eq!(
+        de,
+        err(Error::NoSuchExtension("invalid".to_string()), 1, 18)
+    );
+}
+
+#[test]
+fn multiple_attributes() {
+    #[derive(Debug, Deserialize, PartialEq)]
+    struct New(String);
+    let de: SpannedResult<New> =
+        from_str("#![enable(unwrap_newtypes)] #![enable(unwrap_newtypes)] \"Hello\"");
+
+    assert_eq!(de, Ok(New("Hello".to_owned())));
+}
+
+#[test]
+fn uglified_attribute() {
+    let de: SpannedResult<()> = from_str(
+        "#   !\
+    // We definitely want to add a comment here
+    [\t\tenable( // best style ever
+            unwrap_newtypes  ) ] ()",
+    );
+
+    assert_eq!(de, Ok(()));
+}
+
+#[test]
+fn implicit_some() {
+    use serde::de::DeserializeOwned;
+
+    fn de<T: DeserializeOwned>(s: &str) -> Option<T> {
+        let enable = "#![enable(implicit_some)]\n".to_string();
+
+        from_str::<Option<T>>(&(enable + s)).unwrap()
+    }
+
+    assert_eq!(de("'c'"), Some('c'));
+    assert_eq!(de("5"), Some(5));
+    assert_eq!(de("\"Hello\""), Some("Hello".to_owned()));
+    assert_eq!(de("false"), Some(false));
+    assert_eq!(
+        de("MyStruct(x: .4, y: .5)"),
+        Some(MyStruct { x: 0.4, y: 0.5 })
+    );
+
+    assert_eq!(de::<char>("None"), None);
+
+    // Not concise
+    assert_eq!(de::<Option<Option<char>>>("None"), None);
+}
+
+#[test]
+fn ws_tuple_newtype_variant() {
+    assert_eq!(Ok(MyEnum::B(true)), from_str("B  ( \n true \n ) "));
+}
+
+#[test]
+fn test_byte_stream() {
+    assert_eq!(
+        Ok(BytesStruct {
+            small: vec![1, 2],
+            large: vec![1, 2, 3, 4]
+        }),
+        from_str("BytesStruct( small:[1, 2], large:\"AQIDBA==\" )"),
+    );
+}
+
+#[test]
+fn test_numbers() {
+    assert_eq!(
+        Ok(vec![1234, 12345, 123456, 1234567, 555_555]),
+        from_str("[1_234, 12_345, 1_2_3_4_5_6, 1_234_567, 5_55_55_5]"),
+    );
+}
+
+fn de_any_number(s: &str) -> AnyNum {
+    let mut bytes = Bytes::new(s.as_bytes()).unwrap();
+
+    bytes.any_num().unwrap()
+}
+
+#[test]
+fn test_any_number_precision() {
+    assert_eq!(de_any_number("1"), AnyNum::U8(1));
+    assert_eq!(de_any_number("+1"), AnyNum::I8(1));
+    assert_eq!(de_any_number("-1"), AnyNum::I8(-1));
+    assert_eq!(de_any_number("-1.0"), AnyNum::F32(-1.0));
+    assert_eq!(de_any_number("1."), AnyNum::F32(1.));
+    assert_eq!(de_any_number("-1."), AnyNum::F32(-1.));
+    assert_eq!(de_any_number("0.3"), AnyNum::F64(0.3));
+}

vendor/ron/src/de/value.rs

@@ -0,0 +1,338 @@
+use std::fmt;
+
+use serde::{
+    de::{Error, MapAccess, SeqAccess, Visitor},
+    Deserialize, Deserializer,
+};
+
+use crate::{
+    error::SpannedResult,
+    value::{Map, Number, Value},
+};
+
+impl std::str::FromStr for Value {
+    type Err = crate::error::SpannedError;
+
+    /// Creates a value from a string reference.
+    fn from_str(s: &str) -> SpannedResult<Self> {
+        let mut de = super::Deserializer::from_str(s)?;
+
+        let val = Value::deserialize(&mut de).map_err(|e| de.span_error(e))?;
+        de.end().map_err(|e| de.span_error(e))?;
+
+        Ok(val)
+    }
+}
+
+impl<'de> Deserialize<'de> for Value {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_any(ValueVisitor)
+    }
+}
+
+struct ValueVisitor;
+
+impl<'de> Visitor<'de> for ValueVisitor {
+    type Value = Value;
+
+    fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "a RON value")
+    }
+
+    fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
+    where
+        E: Error,
+    {
+        Ok(Value::Bool(v))
+    }
+
+    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
+    where
+        E: Error,
+    {
+        Ok(Value::Number(Number::new(v)))
+    }
+
+    #[cfg(feature = "integer128")]
+    fn visit_i128<E>(self, v: i128) -> Result<Self::Value, E>
+    where
+        E: Error,
+    {
+        self.visit_f64(v as f64)
+    }
+
+    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
+    where
+        E: Error,
+    {
+        Ok(Value::Number(Number::new(v)))
+    }
+
+    #[cfg(feature = "integer128")]
+    fn visit_u128<E>(self, v: u128) -> Result<Self::Value, E>
+    where
+        E: Error,
+    {
+        self.visit_f64(v as f64)
+    }
+
+    fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>
+    where
+        E: Error,
+    {
+        Ok(Value::Number(Number::new(v)))
+    }
+
+    fn visit_char<E>(self, v: char) -> Result<Self::Value, E>
+    where
+        E: Error,
+    {
+        Ok(Value::Char(v))
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: Error,
+    {
+        self.visit_string(v.to_owned())
+    }
+
+    fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
+    where
+        E: Error,
+    {
+        Ok(Value::String(v))
+    }
+
+    fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
+    where
+        E: Error,
+    {
+        self.visit_byte_buf(v.to_vec())
+    }
+
+    fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
+    where
+        E: Error,
+    {
+        self.visit_string(String::from_utf8(v).map_err(|e| Error::custom(format!("{}", e)))?)
+    }
+
+    fn visit_none<E>(self) -> Result<Self::Value, E>
+    where
+        E: Error,
+    {
+        Ok(Value::Option(None))
+    }
+
+    fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        Ok(Value::Option(Some(Box::new(
+            deserializer.deserialize_any(ValueVisitor)?,
+        ))))
+    }
+
+    fn visit_unit<E>(self) -> Result<Self::Value, E>
+    where
+        E: Error,
+    {
+        Ok(Value::Unit)
+    }
+
+    fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_any(ValueVisitor)
+    }
+
+    fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
+    where
+        A: SeqAccess<'de>,
+    {
+        let mut vec = Vec::new();
+        if let Some(cap) = seq.size_hint() {
+            vec.reserve_exact(cap);
+        }
+
+        while let Some(x) = seq.next_element()? {
+            vec.push(x);
+        }
+
+        Ok(Value::Seq(vec))
+    }
+
+    fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
+    where
+        A: MapAccess<'de>,
+    {
+        let mut res: Map = Map::new();
+
+        while let Some(entry) = map.next_entry()? {
+            res.insert(entry.0, entry.1);
+        }
+
+        Ok(Value::Map(res))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::str::FromStr;
+
+    use super::*;
+
+    fn eval(s: &str) -> Value {
+        s.parse().expect("Failed to parse")
+    }
+
+    #[test]
+    fn test_none() {
+        assert_eq!(eval("None"), Value::Option(None));
+    }
+
+    #[test]
+    fn test_some() {
+        assert_eq!(eval("Some(())"), Value::Option(Some(Box::new(Value::Unit))));
+        assert_eq!(
+            eval("Some  (  () )"),
+            Value::Option(Some(Box::new(Value::Unit)))
+        );
+    }
+
+    #[test]
+    fn test_tuples_basic() {
+        assert_eq!(
+            eval("(3, 4.0, 5.0)"),
+            Value::Seq(vec![
+                Value::Number(Number::new(3)),
+                Value::Number(Number::new(4.0)),
+                Value::Number(Number::new(5.0)),
+            ],),
+        );
+    }
+
+    #[test]
+    fn test_tuples_ident() {
+        assert_eq!(
+            eval("(true, 3, 4, 5.0)"),
+            Value::Seq(vec![
+                Value::Bool(true),
+                Value::Number(Number::new(3)),
+                Value::Number(Number::new(4)),
+                Value::Number(Number::new(5.0)),
+            ]),
+        );
+    }
+
+    #[test]
+    fn test_tuples_error() {
+        use crate::de::{Error, Position, SpannedError};
+
+        assert_eq!(
+            Value::from_str("Foo:").unwrap_err(),
+            SpannedError {
+                code: Error::TrailingCharacters,
+                position: Position { col: 4, line: 1 }
+            },
+        );
+    }
+
+    #[test]
+    fn test_floats() {
+        assert_eq!(
+            eval("(inf, -inf, NaN)"),
+            Value::Seq(vec![
+                Value::Number(Number::new(std::f64::INFINITY)),
+                Value::Number(Number::new(std::f64::NEG_INFINITY)),
+                Value::Number(Number::new(std::f64::NAN)),
+            ]),
+        );
+    }
+
+    #[test]
+    fn test_complex() {
+        assert_eq!(
+            eval(
+                "Some([
+    Room ( width: 20, height: 5, name: \"The Room\" ),
+
+    (
+        width: 10.0,
+        height: 10.0,
+        name: \"Another room\",
+        enemy_levels: {
+            \"Enemy1\": 3,
+            \"Enemy2\": 5,
+            \"Enemy3\": 7,
+        },
+    ),
+])"
+            ),
+            Value::Option(Some(Box::new(Value::Seq(vec![
+                Value::Map(
+                    vec![
+                        (
+                            Value::String("width".to_owned()),
+                            Value::Number(Number::new(20)),
+                        ),
+                        (
+                            Value::String("height".to_owned()),
+                            Value::Number(Number::new(5)),
+                        ),
+                        (
+                            Value::String("name".to_owned()),
+                            Value::String("The Room".to_owned()),
+                        ),
+                    ]
+                    .into_iter()
+                    .collect(),
+                ),
+                Value::Map(
+                    vec![
+                        (
+                            Value::String("width".to_owned()),
+                            Value::Number(Number::new(10.0)),
+                        ),
+                        (
+                            Value::String("height".to_owned()),
+                            Value::Number(Number::new(10.0)),
+                        ),
+                        (
+                            Value::String("name".to_owned()),
+                            Value::String("Another room".to_owned()),
+                        ),
+                        (
+                            Value::String("enemy_levels".to_owned()),
+                            Value::Map(
+                                vec![
+                                    (
+                                        Value::String("Enemy1".to_owned()),
+                                        Value::Number(Number::new(3)),
+                                    ),
+                                    (
+                                        Value::String("Enemy2".to_owned()),
+                                        Value::Number(Number::new(5)),
+                                    ),
+                                    (
+                                        Value::String("Enemy3".to_owned()),
+                                        Value::Number(Number::new(7)),
+                                    ),
+                                ]
+                                .into_iter()
+                                .collect(),
+                            ),
+                        ),
+                    ]
+                    .into_iter()
+                    .collect(),
+                ),
+            ]))))
+        );
+    }
+}

vendor/ron/src/error.rs

@@ -0,0 +1,445 @@
+use std::{error::Error as StdError, fmt, io, str::Utf8Error, string::FromUtf8Error};
+
+use serde::{de, ser};
+
+use crate::parse::{is_ident_first_char, is_ident_other_char, is_ident_raw_char, BASE64_ENGINE};
+
+/// This type represents all possible errors that can occur when
+/// serializing or deserializing RON data.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct SpannedError {
+    pub code: Error,
+    pub position: Position,
+}
+
+pub type Result<T, E = Error> = std::result::Result<T, E>;
+pub type SpannedResult<T> = std::result::Result<T, SpannedError>;
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum Error {
+    Io(String),
+    Message(String),
+    Base64Error(base64::DecodeError),
+    Eof,
+    ExpectedArray,
+    ExpectedArrayEnd,
+    ExpectedAttribute,
+    ExpectedAttributeEnd,
+    ExpectedBoolean,
+    ExpectedComma,
+    ExpectedChar,
+    ExpectedFloat,
+    FloatUnderscore,
+    ExpectedInteger,
+    ExpectedOption,
+    ExpectedOptionEnd,
+    ExpectedMap,
+    ExpectedMapColon,
+    ExpectedMapEnd,
+    ExpectedDifferentStructName {
+        expected: &'static str,
+        found: String,
+    },
+    ExpectedStructLike,
+    ExpectedNamedStructLike(&'static str),
+    ExpectedStructLikeEnd,
+    ExpectedUnit,
+    ExpectedString,
+    ExpectedStringEnd,
+    ExpectedIdentifier,
+
+    InvalidEscape(&'static str),
+
+    IntegerOutOfBounds,
+
+    NoSuchExtension(String),
+
+    UnclosedBlockComment,
+    UnderscoreAtBeginning,
+    UnexpectedByte(char),
+
+    Utf8Error(Utf8Error),
+    TrailingCharacters,
+
+    InvalidValueForType {
+        expected: String,
+        found: String,
+    },
+    ExpectedDifferentLength {
+        expected: String,
+        found: usize,
+    },
+    NoSuchEnumVariant {
+        expected: &'static [&'static str],
+        found: String,
+        outer: Option<String>,
+    },
+    NoSuchStructField {
+        expected: &'static [&'static str],
+        found: String,
+        outer: Option<String>,
+    },
+    MissingStructField {
+        field: &'static str,
+        outer: Option<String>,
+    },
+    DuplicateStructField {
+        field: &'static str,
+        outer: Option<String>,
+    },
+    InvalidIdentifier(String),
+    SuggestRawIdentifier(String),
+    ExceededRecursionLimit,
+}
+
+impl fmt::Display for SpannedError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if (self.position == Position { line: 0, col: 0 }) {
+            write!(f, "{}", self.code)
+        } else {
+            write!(f, "{}: {}", self.position, self.code)
+        }
+    }
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match *self {
+            Error::Io(ref s) => f.write_str(s),
+            Error::Message(ref s) => f.write_str(s),
+            Error::Base64Error(ref e) => fmt::Display::fmt(e, f),
+            Error::Eof => f.write_str("Unexpected end of RON"),
+            Error::ExpectedArray => f.write_str("Expected opening `[`"),
+            Error::ExpectedArrayEnd => f.write_str("Expected closing `]`"),
+            Error::ExpectedAttribute => f.write_str("Expected an `#![enable(...)]` attribute"),
+            Error::ExpectedAttributeEnd => {
+                f.write_str("Expected closing `)]` after the enable attribute")
+            }
+            Error::ExpectedBoolean => f.write_str("Expected boolean"),
+            Error::ExpectedComma => f.write_str("Expected comma"),
+            Error::ExpectedChar => f.write_str("Expected char"),
+            Error::ExpectedFloat => f.write_str("Expected float"),
+            Error::FloatUnderscore => f.write_str("Unexpected underscore in float"),
+            Error::ExpectedInteger => f.write_str("Expected integer"),
+            Error::ExpectedOption => f.write_str("Expected option"),
+            Error::ExpectedOptionEnd => f.write_str("Expected closing `)`"),
+            Error::ExpectedMap => f.write_str("Expected opening `{`"),
+            Error::ExpectedMapColon => f.write_str("Expected colon"),
+            Error::ExpectedMapEnd => f.write_str("Expected closing `}`"),
+            Error::ExpectedDifferentStructName {
+                expected,
+                ref found,
+            } => write!(
+                f,
+                "Expected struct {} but found {}",
+                Identifier(expected),
+                Identifier(found)
+            ),
+            Error::ExpectedStructLike => f.write_str("Expected opening `(`"),
+            Error::ExpectedNamedStructLike(name) => {
+                if name.is_empty() {
+                    f.write_str("Expected only opening `(`, no name, for un-nameable struct")
+                } else {
+                    write!(f, "Expected opening `(` for struct {}", Identifier(name))
+                }
+            }
+            Error::ExpectedStructLikeEnd => f.write_str("Expected closing `)`"),
+            Error::ExpectedUnit => f.write_str("Expected unit"),
+            Error::ExpectedString => f.write_str("Expected string"),
+            Error::ExpectedStringEnd => f.write_str("Expected end of string"),
+            Error::ExpectedIdentifier => f.write_str("Expected identifier"),
+            Error::InvalidEscape(s) => f.write_str(s),
+            Error::IntegerOutOfBounds => f.write_str("Integer is out of bounds"),
+            Error::NoSuchExtension(ref name) => {
+                write!(f, "No RON extension named {}", Identifier(name))
+            }
+            Error::Utf8Error(ref e) => fmt::Display::fmt(e, f),
+            Error::UnclosedBlockComment => f.write_str("Unclosed block comment"),
+            Error::UnderscoreAtBeginning => {
+                f.write_str("Unexpected leading underscore in an integer")
+            }
+            Error::UnexpectedByte(ref byte) => write!(f, "Unexpected byte {:?}", byte),
+            Error::TrailingCharacters => f.write_str("Non-whitespace trailing characters"),
+            Error::InvalidValueForType {
+                ref expected,
+                ref found,
+            } => {
+                write!(f, "Expected {} but found {} instead", expected, found)
+            }
+            Error::ExpectedDifferentLength {
+                ref expected,
+                found,
+            } => {
+                write!(f, "Expected {} but found ", expected)?;
+
+                match found {
+                    0 => f.write_str("zero elements")?,
+                    1 => f.write_str("one element")?,
+                    n => write!(f, "{} elements", n)?,
+                }
+
+                f.write_str(" instead")
+            }
+            Error::NoSuchEnumVariant {
+                expected,
+                ref found,
+                ref outer,
+            } => {
+                f.write_str("Unexpected ")?;
+
+                if outer.is_none() {
+                    f.write_str("enum ")?;
+                }
+
+                write!(f, "variant named {}", Identifier(found))?;
+
+                if let Some(outer) = outer {
+                    write!(f, "in enum {}", Identifier(outer))?;
+                }
+
+                write!(
+                    f,
+                    ", {}",
+                    OneOf {
+                        alts: expected,
+                        none: "variants"
+                    }
+                )
+            }
+            Error::NoSuchStructField {
+                expected,
+                ref found,
+                ref outer,
+            } => {
+                write!(f, "Unexpected field named {}", Identifier(found))?;
+
+                if let Some(outer) = outer {
+                    write!(f, "in {}", Identifier(outer))?;
+                }
+
+                write!(
+                    f,
+                    ", {}",
+                    OneOf {
+                        alts: expected,
+                        none: "fields"
+                    }
+                )
+            }
+            Error::MissingStructField { field, ref outer } => {
+                write!(f, "Unexpected missing field {}", Identifier(field))?;
+
+                match outer {
+                    Some(outer) => write!(f, " in {}", Identifier(outer)),
+                    None => Ok(()),
+                }
+            }
+            Error::DuplicateStructField { field, ref outer } => {
+                write!(f, "Unexpected duplicate field {}", Identifier(field))?;
+
+                match outer {
+                    Some(outer) => write!(f, " in {}", Identifier(outer)),
+                    None => Ok(()),
+                }
+            }
+            Error::InvalidIdentifier(ref invalid) => write!(f, "Invalid identifier {:?}", invalid),
+            Error::SuggestRawIdentifier(ref identifier) => write!(
+                f,
+                "Found invalid std identifier `{}`, try the raw identifier `r#{}` instead",
+                identifier, identifier
+            ),
+            Error::ExceededRecursionLimit => f.write_str("Exceeded recursion limit, try increasing the limit and using `serde_stacker` to protect against a stack overflow"),
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Position {
+    pub line: usize,
+    pub col: usize,
+}
+
+impl fmt::Display for Position {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}:{}", self.line, self.col)
+    }
+}
+
+impl ser::Error for Error {
+    #[cold]
+    fn custom<T: fmt::Display>(msg: T) -> Self {
+        Error::Message(msg.to_string())
+    }
+}
+
+impl de::Error for Error {
+    #[cold]
+    fn custom<T: fmt::Display>(msg: T) -> Self {
+        Error::Message(msg.to_string())
+    }
+
+    #[cold]
+    fn invalid_type(unexp: de::Unexpected, exp: &dyn de::Expected) -> Self {
+        // Invalid type and invalid value are merged given their similarity in ron
+        Self::invalid_value(unexp, exp)
+    }
+
+    #[cold]
+    fn invalid_value(unexp: de::Unexpected, exp: &dyn de::Expected) -> Self {
+        struct UnexpectedSerdeTypeValue<'a>(de::Unexpected<'a>);
+
+        impl<'a> fmt::Display for UnexpectedSerdeTypeValue<'a> {
+            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+                use de::Unexpected::*;
+
+                match self.0 {
+                    Bool(b) => write!(f, "the boolean `{}`", b),
+                    Unsigned(i) => write!(f, "the unsigned integer `{}`", i),
+                    Signed(i) => write!(f, "the signed integer `{}`", i),
+                    Float(n) => write!(f, "the floating point number `{}`", n),
+                    Char(c) => write!(f, "the UTF-8 character `{}`", c),
+                    Str(s) => write!(f, "the string {:?}", s),
+                    Bytes(b) => write!(f, "the bytes \"{}\"", {
+                        base64::display::Base64Display::new(b, &BASE64_ENGINE)
+                    }),
+                    Unit => write!(f, "a unit value"),
+                    Option => write!(f, "an optional value"),
+                    NewtypeStruct => write!(f, "a newtype struct"),
+                    Seq => write!(f, "a sequence"),
+                    Map => write!(f, "a map"),
+                    Enum => write!(f, "an enum"),
+                    UnitVariant => write!(f, "a unit variant"),
+                    NewtypeVariant => write!(f, "a newtype variant"),
+                    TupleVariant => write!(f, "a tuple variant"),
+                    StructVariant => write!(f, "a struct variant"),
+                    Other(other) => f.write_str(other),
+                }
+            }
+        }
+
+        Error::InvalidValueForType {
+            expected: exp.to_string(),
+            found: UnexpectedSerdeTypeValue(unexp).to_string(),
+        }
+    }
+
+    #[cold]
+    fn invalid_length(len: usize, exp: &dyn de::Expected) -> Self {
+        Error::ExpectedDifferentLength {
+            expected: exp.to_string(),
+            found: len,
+        }
+    }
+
+    #[cold]
+    fn unknown_variant(variant: &str, expected: &'static [&'static str]) -> Self {
+        Error::NoSuchEnumVariant {
+            expected,
+            found: variant.to_string(),
+            outer: None,
+        }
+    }
+
+    #[cold]
+    fn unknown_field(field: &str, expected: &'static [&'static str]) -> Self {
+        Error::NoSuchStructField {
+            expected,
+            found: field.to_string(),
+            outer: None,
+        }
+    }
+
+    #[cold]
+    fn missing_field(field: &'static str) -> Self {
+        Error::MissingStructField { field, outer: None }
+    }
+
+    #[cold]
+    fn duplicate_field(field: &'static str) -> Self {
+        Error::DuplicateStructField { field, outer: None }
+    }
+}
+
+impl StdError for SpannedError {}
+impl StdError for Error {}
+
+impl From<Utf8Error> for Error {
+    fn from(e: Utf8Error) -> Self {
+        Error::Utf8Error(e)
+    }
+}
+
+impl From<FromUtf8Error> for Error {
+    fn from(e: FromUtf8Error) -> Self {
+        Error::Utf8Error(e.utf8_error())
+    }
+}
+
+impl From<io::Error> for Error {
+    fn from(e: io::Error) -> Self {
+        Error::Io(e.to_string())
+    }
+}
+
+impl From<io::Error> for SpannedError {
+    fn from(e: io::Error) -> Self {
+        SpannedError {
+            code: e.into(),
+            position: Position { line: 0, col: 0 },
+        }
+    }
+}
+
+impl From<SpannedError> for Error {
+    fn from(e: SpannedError) -> Self {
+        e.code
+    }
+}
+
+struct OneOf {
+    alts: &'static [&'static str],
+    none: &'static str,
+}
+
+impl fmt::Display for OneOf {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self.alts {
+            [] => write!(f, "there are no {}", self.none),
+            [a1] => write!(f, "expected {} instead", Identifier(a1)),
+            [a1, a2] => write!(
+                f,
+                "expected either {} or {} instead",
+                Identifier(a1),
+                Identifier(a2)
+            ),
+            [a1, ref alts @ ..] => {
+                write!(f, "expected one of {}", Identifier(a1))?;
+
+                for alt in alts {
+                    write!(f, ", {}", Identifier(alt))?;
+                }
+
+                f.write_str(" instead")
+            }
+        }
+    }
+}
+
+struct Identifier<'a>(&'a str);
+
+impl<'a> fmt::Display for Identifier<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if self.0.is_empty() || !self.0.as_bytes().iter().copied().all(is_ident_raw_char) {
+            return write!(f, "{:?}_[invalid identifier]", self.0);
+        }
+
+        let mut bytes = self.0.as_bytes().iter().copied();
+
+        if !bytes.next().map_or(false, is_ident_first_char) || !bytes.all(is_ident_other_char) {
+            write!(f, "`r#{}`", self.0)
+        } else {
+            write!(f, "`{}`", self.0)
+        }
+    }
+}

vendor/ron/src/extensions.rs

@@ -0,0 +1,55 @@
+use serde_derive::{Deserialize, Serialize};
+
+bitflags::bitflags! {
+    #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+    pub struct Extensions: usize {
+        const UNWRAP_NEWTYPES = 0x1;
+        const IMPLICIT_SOME = 0x2;
+        const UNWRAP_VARIANT_NEWTYPES = 0x4;
+    }
+}
+
+impl Extensions {
+    /// Creates an extension flag from an ident.
+    pub fn from_ident(ident: &[u8]) -> Option<Extensions> {
+        match ident {
+            b"unwrap_newtypes" => Some(Extensions::UNWRAP_NEWTYPES),
+            b"implicit_some" => Some(Extensions::IMPLICIT_SOME),
+            b"unwrap_variant_newtypes" => Some(Extensions::UNWRAP_VARIANT_NEWTYPES),
+            _ => None,
+        }
+    }
+}
+
+impl Default for Extensions {
+    fn default() -> Self {
+        Extensions::empty()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::Extensions;
+
+    fn roundtrip_extensions(ext: Extensions) {
+        let ron = crate::to_string(&ext).unwrap();
+        let ext2: Extensions = crate::from_str(&ron).unwrap();
+        assert_eq!(ext, ext2);
+    }
+
+    #[test]
+    fn test_extension_serde() {
+        roundtrip_extensions(Extensions::default());
+        roundtrip_extensions(Extensions::UNWRAP_NEWTYPES);
+        roundtrip_extensions(Extensions::IMPLICIT_SOME);
+        roundtrip_extensions(Extensions::UNWRAP_VARIANT_NEWTYPES);
+        roundtrip_extensions(Extensions::UNWRAP_NEWTYPES | Extensions::IMPLICIT_SOME);
+        roundtrip_extensions(Extensions::UNWRAP_NEWTYPES | Extensions::UNWRAP_VARIANT_NEWTYPES);
+        roundtrip_extensions(Extensions::IMPLICIT_SOME | Extensions::UNWRAP_VARIANT_NEWTYPES);
+        roundtrip_extensions(
+            Extensions::UNWRAP_NEWTYPES
+                | Extensions::IMPLICIT_SOME
+                | Extensions::UNWRAP_VARIANT_NEWTYPES,
+        );
+    }
+}

vendor/ron/src/lib.rs

@@ -0,0 +1,20 @@
+#![doc = include_str!("../README.md")]
+#![doc(html_root_url = "https://docs.rs/ron/0.8.1")]
+
+pub mod de;
+pub mod ser;
+
+pub mod error;
+pub mod value;
+
+pub mod extensions;
+
+pub mod options;
+
+pub use de::{from_str, Deserializer};
+pub use error::{Error, Result};
+pub use options::Options;
+pub use ser::{to_string, Serializer};
+pub use value::{Map, Number, Value};
+
+mod parse;

vendor/ron/src/options.rs

@@ -0,0 +1,215 @@
+//! Roundtrip serde Options module.
+
+use std::io;
+
+use serde::{de, ser};
+use serde_derive::{Deserialize, Serialize};
+
+use crate::{
+    de::Deserializer,
+    error::{Result, SpannedResult},
+    extensions::Extensions,
+    ser::{PrettyConfig, Serializer},
+};
+
+/// Roundtrip serde options.
+///
+/// # Examples
+///
+/// ```
+/// use ron::{Options, extensions::Extensions};
+///
+/// let ron = Options::default()
+///     .with_default_extension(Extensions::IMPLICIT_SOME);
+///
+/// let de: Option<i32> = ron.from_str("42").unwrap();
+/// let ser = ron.to_string(&de).unwrap();
+///
+/// assert_eq!(ser, "42");
+/// ```
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(default)]
+#[non_exhaustive]
+pub struct Options {
+    /// Extensions that are enabled by default during serialization and
+    ///  deserialization.
+    /// During serialization, these extensions do NOT have to be explicitly
+    ///  enabled in the parsed RON.
+    /// During deserialization, these extensions are used, but their explicit
+    ///  activation is NOT included in the output RON.
+    /// No extensions are enabled by default.
+    pub default_extensions: Extensions,
+    /// Default recursion limit that is checked during serialization and
+    ///  deserialization.
+    /// If set to `None`, infinite recursion is allowed and stack overflow
+    ///  errors can crash the serialization or deserialization process.
+    /// Defaults to `Some(128)`, i.e. 128 recursive calls are allowed.
+    pub recursion_limit: Option<usize>,
+}
+
+impl Default for Options {
+    fn default() -> Self {
+        Self {
+            default_extensions: Extensions::empty(),
+            recursion_limit: Some(128),
+        }
+    }
+}
+
+impl Options {
+    #[must_use]
+    /// Enable `default_extension` by default during serialization and deserialization.
+    pub fn with_default_extension(mut self, default_extension: Extensions) -> Self {
+        self.default_extensions |= default_extension;
+        self
+    }
+
+    #[must_use]
+    /// Do NOT enable `default_extension` by default during serialization and deserialization.
+    pub fn without_default_extension(mut self, default_extension: Extensions) -> Self {
+        self.default_extensions &= !default_extension;
+        self
+    }
+
+    #[must_use]
+    /// Set a maximum recursion limit during serialization and deserialization.
+    pub fn with_recursion_limit(mut self, recursion_limit: usize) -> Self {
+        self.recursion_limit = Some(recursion_limit);
+        self
+    }
+
+    #[must_use]
+    /// Disable the recursion limit during serialization and deserialization.
+    ///
+    /// If you expect to handle highly recursive datastructures, consider wrapping
+    /// `ron` with [`serde_stacker`](https://docs.rs/serde_stacker/latest/serde_stacker/).
+    pub fn without_recursion_limit(mut self) -> Self {
+        self.recursion_limit = None;
+        self
+    }
+}
+
+impl Options {
+    /// A convenience function for building a deserializer
+    /// and deserializing a value of type `T` from a reader.
+    pub fn from_reader<R, T>(&self, mut rdr: R) -> SpannedResult<T>
+    where
+        R: io::Read,
+        T: de::DeserializeOwned,
+    {
+        let mut bytes = Vec::new();
+        rdr.read_to_end(&mut bytes)?;
+
+        self.from_bytes(&bytes)
+    }
+
+    /// A convenience function for building a deserializer
+    /// and deserializing a value of type `T` from a string.
+    pub fn from_str<'a, T>(&self, s: &'a str) -> SpannedResult<T>
+    where
+        T: de::Deserialize<'a>,
+    {
+        self.from_bytes(s.as_bytes())
+    }
+
+    /// A convenience function for building a deserializer
+    /// and deserializing a value of type `T` from bytes.
+    pub fn from_bytes<'a, T>(&self, s: &'a [u8]) -> SpannedResult<T>
+    where
+        T: de::Deserialize<'a>,
+    {
+        self.from_bytes_seed(s, std::marker::PhantomData)
+    }
+
+    /// A convenience function for building a deserializer
+    /// and deserializing a value of type `T` from a reader
+    /// and a seed.
+    pub fn from_reader_seed<R, S, T>(&self, mut rdr: R, seed: S) -> SpannedResult<T>
+    where
+        R: io::Read,
+        S: for<'a> de::DeserializeSeed<'a, Value = T>,
+    {
+        let mut bytes = Vec::new();
+        rdr.read_to_end(&mut bytes)?;
+
+        self.from_bytes_seed(&bytes, seed)
+    }
+
+    /// A convenience function for building a deserializer
+    /// and deserializing a value of type `T` from a string
+    /// and a seed.
+    pub fn from_str_seed<'a, S, T>(&self, s: &'a str, seed: S) -> SpannedResult<T>
+    where
+        S: de::DeserializeSeed<'a, Value = T>,
+    {
+        self.from_bytes_seed(s.as_bytes(), seed)
+    }
+
+    /// A convenience function for building a deserializer
+    /// and deserializing a value of type `T` from bytes
+    /// and a seed.
+    pub fn from_bytes_seed<'a, S, T>(&self, s: &'a [u8], seed: S) -> SpannedResult<T>
+    where
+        S: de::DeserializeSeed<'a, Value = T>,
+    {
+        let mut deserializer = Deserializer::from_bytes_with_options(s, self.clone())?;
+
+        let value = seed
+            .deserialize(&mut deserializer)
+            .map_err(|e| deserializer.span_error(e))?;
+
+        deserializer.end().map_err(|e| deserializer.span_error(e))?;
+
+        Ok(value)
+    }
+
+    /// Serializes `value` into `writer`.
+    ///
+    /// This function does not generate any newlines or nice formatting;
+    /// if you want that, you can use
+    /// [`to_writer_pretty`][Self::to_writer_pretty] instead.
+    pub fn to_writer<W, T>(&self, writer: W, value: &T) -> Result<()>
+    where
+        W: io::Write,
+        T: ?Sized + ser::Serialize,
+    {
+        let mut s = Serializer::with_options(writer, None, self.clone())?;
+        value.serialize(&mut s)
+    }
+
+    /// Serializes `value` into `writer` in a pretty way.
+    pub fn to_writer_pretty<W, T>(&self, writer: W, value: &T, config: PrettyConfig) -> Result<()>
+    where
+        W: io::Write,
+        T: ?Sized + ser::Serialize,
+    {
+        let mut s = Serializer::with_options(writer, Some(config), self.clone())?;
+        value.serialize(&mut s)
+    }
+
+    /// Serializes `value` and returns it as string.
+    ///
+    /// This function does not generate any newlines or nice formatting;
+    /// if you want that, you can use
+    /// [`to_string_pretty`][Self::to_string_pretty] instead.
+    pub fn to_string<T>(&self, value: &T) -> Result<String>
+    where
+        T: ?Sized + ser::Serialize,
+    {
+        let mut output = Vec::new();
+        let mut s = Serializer::with_options(&mut output, None, self.clone())?;
+        value.serialize(&mut s)?;
+        Ok(String::from_utf8(output).expect("Ron should be utf-8"))
+    }
+
+    /// Serializes `value` in the recommended RON layout in a pretty way.
+    pub fn to_string_pretty<T>(&self, value: &T, config: PrettyConfig) -> Result<String>
+    where
+        T: ?Sized + ser::Serialize,
+    {
+        let mut output = Vec::new();
+        let mut s = Serializer::with_options(&mut output, Some(config), self.clone())?;
+        value.serialize(&mut s)?;
+        Ok(String::from_utf8(output).expect("Ron should be utf-8"))
+    }
+}

vendor/ron/src/ser/tests.rs

@@ -0,0 +1,147 @@
+use serde_derive::Serialize;
+
+use super::to_string;
+
+#[derive(Serialize)]
+struct EmptyStruct1;
+
+#[derive(Serialize)]
+struct EmptyStruct2 {}
+
+#[derive(Serialize)]
+struct MyStruct {
+    x: f32,
+    y: f32,
+}
+
+#[derive(Serialize)]
+enum MyEnum {
+    A,
+    B(bool),
+    C(bool, f32),
+    D { a: i32, b: i32 },
+}
+
+#[test]
+fn test_empty_struct() {
+    assert_eq!(to_string(&EmptyStruct1).unwrap(), "()");
+    assert_eq!(to_string(&EmptyStruct2 {}).unwrap(), "()");
+}
+
+#[test]
+fn test_struct() {
+    let my_struct = MyStruct { x: 4.0, y: 7.0 };
+
+    assert_eq!(to_string(&my_struct).unwrap(), "(x:4.0,y:7.0)");
+
+    #[derive(Serialize)]
+    struct NewType(i32);
+
+    assert_eq!(to_string(&NewType(42)).unwrap(), "(42)");
+
+    #[derive(Serialize)]
+    struct TupleStruct(f32, f32);
+
+    assert_eq!(to_string(&TupleStruct(2.0, 5.0)).unwrap(), "(2.0,5.0)");
+}
+
+#[test]
+fn test_option() {
+    assert_eq!(to_string(&Some(1u8)).unwrap(), "Some(1)");
+    assert_eq!(to_string(&None::<u8>).unwrap(), "None");
+}
+
+#[test]
+fn test_enum() {
+    assert_eq!(to_string(&MyEnum::A).unwrap(), "A");
+    assert_eq!(to_string(&MyEnum::B(true)).unwrap(), "B(true)");
+    assert_eq!(to_string(&MyEnum::C(true, 3.5)).unwrap(), "C(true,3.5)");
+    assert_eq!(to_string(&MyEnum::D { a: 2, b: 3 }).unwrap(), "D(a:2,b:3)");
+}
+
+#[test]
+fn test_array() {
+    let empty: [i32; 0] = [];
+    assert_eq!(to_string(&empty).unwrap(), "()");
+    let empty_ref: &[i32] = &empty;
+    assert_eq!(to_string(&empty_ref).unwrap(), "[]");
+
+    assert_eq!(to_string(&[2, 3, 4i32]).unwrap(), "(2,3,4)");
+    assert_eq!(to_string(&(&[2, 3, 4i32] as &[i32])).unwrap(), "[2,3,4]");
+}
+
+#[test]
+fn test_slice() {
+    assert_eq!(to_string(&[0, 1, 2, 3, 4, 5][..]).unwrap(), "[0,1,2,3,4,5]");
+    assert_eq!(to_string(&[0, 1, 2, 3, 4, 5][1..4]).unwrap(), "[1,2,3]");
+}
+
+#[test]
+fn test_vec() {
+    assert_eq!(to_string(&vec![0, 1, 2, 3, 4, 5]).unwrap(), "[0,1,2,3,4,5]");
+}
+
+#[test]
+fn test_map() {
+    use std::collections::HashMap;
+
+    let mut map = HashMap::new();
+    map.insert((true, false), 4);
+    map.insert((false, false), 123);
+
+    let s = to_string(&map).unwrap();
+    s.starts_with('{');
+    s.contains("(true,false):4");
+    s.contains("(false,false):123");
+    s.ends_with('}');
+}
+
+#[test]
+fn test_string() {
+    assert_eq!(to_string(&"Some string").unwrap(), "\"Some string\"");
+}
+
+#[test]
+fn test_char() {
+    assert_eq!(to_string(&'c').unwrap(), "'c'");
+}
+
+#[test]
+fn test_escape() {
+    assert_eq!(to_string(&r#""Quoted""#).unwrap(), r#""\"Quoted\"""#);
+}
+
+#[test]
+fn test_byte_stream() {
+    use serde_bytes;
+
+    let small: [u8; 16] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15];
+    assert_eq!(
+        to_string(&small).unwrap(),
+        "(0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15)"
+    );
+
+    let large = vec![255u8; 64];
+    let large = serde_bytes::Bytes::new(&large);
+    assert_eq!(
+        to_string(&large).unwrap(),
+        concat!(
+            "\"/////////////////////////////////////////",
+            "////////////////////////////////////////////w==\""
+        )
+    );
+}
+
+#[test]
+fn rename() {
+    #[derive(Serialize, Debug, PartialEq)]
+    enum Foo {
+        #[serde(rename = "2d")]
+        D2,
+        #[serde(rename = "triangle-list")]
+        TriangleList,
+    }
+
+    assert_eq!(to_string(&Foo::D2).unwrap(), "r#2d");
+    assert_eq!(to_string(&Foo::TriangleList).unwrap(), "r#triangle-list");
+}

vendor/ron/src/ser/value.rs

@@ -0,0 +1,23 @@
+use serde::ser::{Serialize, Serializer};
+
+use crate::value::{Number, Value};
+
+impl Serialize for Value {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match *self {
+            Value::Bool(b) => serializer.serialize_bool(b),
+            Value::Char(c) => serializer.serialize_char(c),
+            Value::Map(ref m) => Serialize::serialize(m, serializer),
+            Value::Number(Number::Float(ref f)) => serializer.serialize_f64(f.get()),
+            Value::Number(Number::Integer(i)) => serializer.serialize_i64(i),
+            Value::Option(Some(ref o)) => serializer.serialize_some(o.as_ref()),
+            Value::Option(None) => serializer.serialize_none(),
+            Value::String(ref s) => serializer.serialize_str(s),
+            Value::Seq(ref s) => Serialize::serialize(s, serializer),
+            Value::Unit => serializer.serialize_unit(),
+        }
+    }
+}

vendor/ron/src/value.rs

@@ -0,0 +1,619 @@
+//! Value module.
+
+use std::{
+    cmp::{Eq, Ordering},
+    hash::{Hash, Hasher},
+    iter::FromIterator,
+    ops::{Index, IndexMut},
+};
+
+use serde::{
+    de::{DeserializeOwned, DeserializeSeed, Deserializer, MapAccess, SeqAccess, Visitor},
+    forward_to_deserialize_any,
+};
+use serde_derive::{Deserialize, Serialize};
+
+use crate::{de::Error, error::Result};
+
+/// A [`Value`] to [`Value`] map.
+///
+/// This structure either uses a [BTreeMap](std::collections::BTreeMap) or the
+/// [IndexMap](indexmap::IndexMap) internally.
+/// The latter can be used by enabling the `indexmap` feature. This can be used
+/// to preserve the order of the parsed map.
+#[derive(Clone, Debug, Default, Deserialize, Serialize)]
+#[serde(transparent)]
+pub struct Map(MapInner);
+
+impl Map {
+    /// Creates a new, empty [`Map`].
+    pub fn new() -> Map {
+        Default::default()
+    }
+
+    /// Returns the number of elements in the map.
+    pub fn len(&self) -> usize {
+        self.0.len()
+    }
+
+    /// Returns `true` if `self.len() == 0`, `false` otherwise.
+    pub fn is_empty(&self) -> bool {
+        self.0.len() == 0
+    }
+
+    /// Inserts a new element, returning the previous element with this `key` if
+    /// there was any.
+    pub fn insert(&mut self, key: Value, value: Value) -> Option<Value> {
+        self.0.insert(key, value)
+    }
+
+    /// Removes an element by its `key`.
+    pub fn remove(&mut self, key: &Value) -> Option<Value> {
+        self.0.remove(key)
+    }
+
+    /// Iterate all key-value pairs.
+    pub fn iter(&self) -> impl Iterator<Item = (&Value, &Value)> + DoubleEndedIterator {
+        self.0.iter()
+    }
+
+    /// Iterate all key-value pairs mutably.
+    pub fn iter_mut(&mut self) -> impl Iterator<Item = (&Value, &mut Value)> + DoubleEndedIterator {
+        self.0.iter_mut()
+    }
+
+    /// Iterate all keys.
+    pub fn keys(&self) -> impl Iterator<Item = &Value> + DoubleEndedIterator {
+        self.0.keys()
+    }
+
+    /// Iterate all values.
+    pub fn values(&self) -> impl Iterator<Item = &Value> + DoubleEndedIterator {
+        self.0.values()
+    }
+
+    /// Iterate all values mutably.
+    pub fn values_mut(&mut self) -> impl Iterator<Item = &mut Value> + DoubleEndedIterator {
+        self.0.values_mut()
+    }
+
+    /// Retains only the elements specified by the `keep` predicate.
+    ///
+    /// In other words, remove all pairs `(k, v)` for which `keep(&k, &mut v)`
+    /// returns `false`.
+    ///
+    /// The elements are visited in iteration order.
+    pub fn retain<F>(&mut self, keep: F)
+    where
+        F: FnMut(&Value, &mut Value) -> bool,
+    {
+        self.0.retain(keep);
+    }
+}
+
+impl FromIterator<(Value, Value)> for Map {
+    fn from_iter<T: IntoIterator<Item = (Value, Value)>>(iter: T) -> Self {
+        Map(MapInner::from_iter(iter))
+    }
+}
+
+impl IntoIterator for Map {
+    type Item = (Value, Value);
+
+    type IntoIter = <MapInner as IntoIterator>::IntoIter;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.0.into_iter()
+    }
+}
+
+/// Note: equality is only given if both values and order of values match
+impl Eq for Map {}
+
+impl Hash for Map {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.iter().for_each(|x| x.hash(state));
+    }
+}
+
+impl Index<&Value> for Map {
+    type Output = Value;
+
+    fn index(&self, index: &Value) -> &Self::Output {
+        &self.0[index]
+    }
+}
+
+impl IndexMut<&Value> for Map {
+    fn index_mut(&mut self, index: &Value) -> &mut Self::Output {
+        self.0.get_mut(index).expect("no entry found for key")
+    }
+}
+
+impl Ord for Map {
+    fn cmp(&self, other: &Map) -> Ordering {
+        self.iter().cmp(other.iter())
+    }
+}
+
+/// Note: equality is only given if both values and order of values match
+impl PartialEq for Map {
+    fn eq(&self, other: &Map) -> bool {
+        self.iter().zip(other.iter()).all(|(a, b)| a == b)
+    }
+}
+
+impl PartialOrd for Map {
+    fn partial_cmp(&self, other: &Map) -> Option<Ordering> {
+        self.iter().partial_cmp(other.iter())
+    }
+}
+
+#[cfg(not(feature = "indexmap"))]
+type MapInner = std::collections::BTreeMap<Value, Value>;
+#[cfg(feature = "indexmap")]
+type MapInner = indexmap::IndexMap<Value, Value>;
+
+/// A wrapper for a number, which can be either [`f64`] or [`i64`].
+#[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq, Hash, Ord)]
+pub enum Number {
+    Integer(i64),
+    Float(Float),
+}
+
+/// A wrapper for [`f64`], which guarantees that the inner value
+/// is finite and thus implements [`Eq`], [`Hash`] and [`Ord`].
+#[derive(Copy, Clone, Debug)]
+pub struct Float(f64);
+
+impl Float {
+    /// Construct a new [`Float`].
+    pub fn new(v: f64) -> Self {
+        Float(v)
+    }
+
+    /// Returns the wrapped float.
+    pub fn get(self) -> f64 {
+        self.0
+    }
+}
+
+impl Number {
+    /// Construct a new number.
+    pub fn new(v: impl Into<Number>) -> Self {
+        v.into()
+    }
+
+    /// Returns the [`f64`] representation of the [`Number`] regardless of
+    /// whether the number is stored as a float or integer.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use ron::value::Number;
+    /// let i = Number::new(5);
+    /// let f = Number::new(2.0);
+    /// assert_eq!(i.into_f64(), 5.0);
+    /// assert_eq!(f.into_f64(), 2.0);
+    /// ```
+    pub fn into_f64(self) -> f64 {
+        self.map_to(|i| i as f64, |f| f)
+    }
+
+    /// If the [`Number`] is a float, return it. Otherwise return [`None`].
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use ron::value::Number;
+    /// let i = Number::new(5);
+    /// let f = Number::new(2.0);
+    /// assert_eq!(i.as_f64(), None);
+    /// assert_eq!(f.as_f64(), Some(2.0));
+    /// ```
+    pub fn as_f64(self) -> Option<f64> {
+        self.map_to(|_| None, Some)
+    }
+
+    /// If the [`Number`] is an integer, return it. Otherwise return [`None`].
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use ron::value::Number;
+    /// let i = Number::new(5);
+    /// let f = Number::new(2.0);
+    /// assert_eq!(i.as_i64(), Some(5));
+    /// assert_eq!(f.as_i64(), None);
+    /// ```
+    pub fn as_i64(self) -> Option<i64> {
+        self.map_to(Some, |_| None)
+    }
+
+    /// Map this number to a single type using the appropriate closure.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use ron::value::Number;
+    /// let i = Number::new(5);
+    /// let f = Number::new(2.0);
+    /// assert!(i.map_to(|i| i > 3, |f| f > 3.0));
+    /// assert!(!f.map_to(|i| i > 3, |f| f > 3.0));
+    /// ```
+    pub fn map_to<T>(
+        self,
+        integer_fn: impl FnOnce(i64) -> T,
+        float_fn: impl FnOnce(f64) -> T,
+    ) -> T {
+        match self {
+            Number::Integer(i) => integer_fn(i),
+            Number::Float(Float(f)) => float_fn(f),
+        }
+    }
+}
+
+impl From<f64> for Number {
+    fn from(f: f64) -> Number {
+        Number::Float(Float(f))
+    }
+}
+
+impl From<i64> for Number {
+    fn from(i: i64) -> Number {
+        Number::Integer(i)
+    }
+}
+
+impl From<i32> for Number {
+    fn from(i: i32) -> Number {
+        Number::Integer(i64::from(i))
+    }
+}
+
+/// The following [`Number`] conversion checks if the integer fits losslessly
+/// into an [`i64`], before constructing a [`Number::Integer`] variant.
+/// If not, the conversion defaults to [`Number::Float`].
+
+impl From<u64> for Number {
+    fn from(i: u64) -> Number {
+        if i <= std::i64::MAX as u64 {
+            Number::Integer(i as i64)
+        } else {
+            Number::new(i as f64)
+        }
+    }
+}
+
+/// Partial equality comparison
+/// In order to be able to use [`Number`] as a mapping key, NaN floating values
+/// wrapped in [`Float`] are equal to each other. It is not the case for
+/// underlying [`f64`] values itself.
+impl PartialEq for Float {
+    fn eq(&self, other: &Self) -> bool {
+        self.0.is_nan() && other.0.is_nan() || self.0 == other.0
+    }
+}
+
+/// Equality comparison
+/// In order to be able to use [`Float`] as a mapping key, NaN floating values
+/// wrapped in [`Float`] are equal to each other. It is not the case for
+/// underlying [`f64`] values itself.
+impl Eq for Float {}
+
+impl Hash for Float {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        state.write_u64(self.0.to_bits());
+    }
+}
+
+/// Partial ordering comparison
+/// In order to be able to use [`Number`] as a mapping key, NaN floating values
+/// wrapped in [`Number`] are equal to each other and are less then any other
+/// floating value. It is not the case for the underlying [`f64`] values
+/// themselves.
+///
+/// ```
+/// use ron::value::Number;
+/// assert!(Number::new(std::f64::NAN) < Number::new(std::f64::NEG_INFINITY));
+/// assert_eq!(Number::new(std::f64::NAN), Number::new(std::f64::NAN));
+/// ```
+impl PartialOrd for Float {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        match (self.0.is_nan(), other.0.is_nan()) {
+            (true, true) => Some(Ordering::Equal),
+            (true, false) => Some(Ordering::Less),
+            (false, true) => Some(Ordering::Greater),
+            _ => self.0.partial_cmp(&other.0),
+        }
+    }
+}
+
+/// Ordering comparison
+/// In order to be able to use [`Float`] as a mapping key, NaN floating values
+/// wrapped in [`Float`] are equal to each other and are less then any other
+/// floating value. It is not the case for underlying [`f64`] values itself.
+/// See the [`PartialEq`] implementation.
+impl Ord for Float {
+    fn cmp(&self, other: &Self) -> Ordering {
+        self.partial_cmp(other).expect("Bug: Contract violation")
+    }
+}
+
+#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub enum Value {
+    Bool(bool),
+    Char(char),
+    Map(Map),
+    Number(Number),
+    Option(Option<Box<Value>>),
+    String(String),
+    Seq(Vec<Value>),
+    Unit,
+}
+
+impl Value {
+    /// Tries to deserialize this [`Value`] into `T`.
+    pub fn into_rust<T>(self) -> Result<T>
+    where
+        T: DeserializeOwned,
+    {
+        T::deserialize(self)
+    }
+}
+
+/// Deserializer implementation for RON [`Value`].
+/// This does not support enums (because [`Value`] does not store them).
+impl<'de> Deserializer<'de> for Value {
+    type Error = Error;
+
+    forward_to_deserialize_any! {
+        bool f32 f64 char str string bytes
+        byte_buf option unit unit_struct newtype_struct seq tuple
+        tuple_struct map struct enum identifier ignored_any
+    }
+
+    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        match self {
+            Value::Bool(b) => visitor.visit_bool(b),
+            Value::Char(c) => visitor.visit_char(c),
+            Value::Map(m) => {
+                let old_len = m.len();
+
+                let mut items: Vec<(Value, Value)> = m.into_iter().collect();
+                items.reverse();
+
+                let value = visitor.visit_map(MapAccessor {
+                    items: &mut items,
+                    value: None,
+                })?;
+
+                if items.is_empty() {
+                    Ok(value)
+                } else {
+                    Err(Error::ExpectedDifferentLength {
+                        expected: format!("a map of length {}", old_len - items.len()),
+                        found: old_len,
+                    })
+                }
+            }
+            Value::Number(Number::Float(ref f)) => visitor.visit_f64(f.get()),
+            Value::Number(Number::Integer(i)) => visitor.visit_i64(i),
+            Value::Option(Some(o)) => visitor.visit_some(*o),
+            Value::Option(None) => visitor.visit_none(),
+            Value::String(s) => visitor.visit_string(s),
+            Value::Seq(mut seq) => {
+                let old_len = seq.len();
+
+                seq.reverse();
+                let value = visitor.visit_seq(Seq { seq: &mut seq })?;
+
+                if seq.is_empty() {
+                    Ok(value)
+                } else {
+                    Err(Error::ExpectedDifferentLength {
+                        expected: format!("a sequence of length {}", old_len - seq.len()),
+                        found: old_len,
+                    })
+                }
+            }
+            Value::Unit => visitor.visit_unit(),
+        }
+    }
+
+    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.deserialize_i64(visitor)
+    }
+
+    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.deserialize_i64(visitor)
+    }
+
+    fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.deserialize_i64(visitor)
+    }
+
+    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        match self {
+            Value::Number(Number::Integer(i)) => visitor.visit_i64(i),
+            v => Err(Error::Message(format!("Expected a number, got {:?}", v))),
+        }
+    }
+
+    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.deserialize_u64(visitor)
+    }
+
+    fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.deserialize_u64(visitor)
+    }
+
+    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        self.deserialize_u64(visitor)
+    }
+
+    fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: Visitor<'de>,
+    {
+        match self {
+            Value::Number(Number::Integer(i)) => visitor.visit_u64(i as u64),
+            v => Err(Error::Message(format!("Expected a number, got {:?}", v))),
+        }
+    }
+}
+
+struct MapAccessor<'a> {
+    items: &'a mut Vec<(Value, Value)>,
+    value: Option<Value>,
+}
+
+impl<'a, 'de> MapAccess<'de> for MapAccessor<'a> {
+    type Error = Error;
+
+    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
+    where
+        K: DeserializeSeed<'de>,
+    {
+        // The `Vec` is reversed, so we can pop to get the originally first element
+        match self.items.pop() {
+            Some((key, value)) => {
+                self.value = Some(value);
+                seed.deserialize(key).map(Some)
+            }
+            None => Ok(None),
+        }
+    }
+
+    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
+    where
+        V: DeserializeSeed<'de>,
+    {
+        match self.value.take() {
+            Some(value) => seed.deserialize(value),
+            None => panic!("Contract violation: value before key"),
+        }
+    }
+
+    fn size_hint(&self) -> Option<usize> {
+        Some(self.items.len())
+    }
+}
+
+struct Seq<'a> {
+    seq: &'a mut Vec<Value>,
+}
+
+impl<'a, 'de> SeqAccess<'de> for Seq<'a> {
+    type Error = Error;
+
+    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
+    where
+        T: DeserializeSeed<'de>,
+    {
+        // The `Vec` is reversed, so we can pop to get the originally first element
+        self.seq
+            .pop()
+            .map_or(Ok(None), |v| seed.deserialize(v).map(Some))
+    }
+
+    fn size_hint(&self) -> Option<usize> {
+        Some(self.seq.len())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::{collections::BTreeMap, fmt::Debug};
+
+    use serde::Deserialize;
+
+    use super::*;
+
+    fn assert_same<'de, T>(s: &'de str)
+    where
+        T: Debug + Deserialize<'de> + PartialEq,
+    {
+        use crate::de::from_str;
+
+        let direct: T = from_str(s).unwrap();
+        let value: Value = from_str(s).unwrap();
+        let value = T::deserialize(value).unwrap();
+
+        assert_eq!(direct, value, "Deserialization for {:?} is not the same", s);
+    }
+
+    #[test]
+    fn boolean() {
+        assert_same::<bool>("true");
+        assert_same::<bool>("false");
+    }
+
+    #[test]
+    fn float() {
+        assert_same::<f64>("0.123");
+        assert_same::<f64>("-4.19");
+    }
+
+    #[test]
+    fn int() {
+        assert_same::<u32>("626");
+        assert_same::<i32>("-50");
+    }
+
+    #[test]
+    fn char() {
+        assert_same::<char>("'4'");
+        assert_same::<char>("'c'");
+    }
+
+    #[test]
+    fn map() {
+        assert_same::<BTreeMap<char, String>>(
+            "{
+'a': \"Hello\",
+'b': \"Bye\",
+        }",
+        );
+    }
+
+    #[test]
+    fn option() {
+        assert_same::<Option<char>>("Some('a')");
+        assert_same::<Option<char>>("None");
+    }
+
+    #[test]
+    fn seq() {
+        assert_same::<Vec<f64>>("[1.0, 2.0, 3.0, 4.0]");
+    }
+
+    #[test]
+    fn unit() {
+        assert_same::<()>("()");
+    }
+}