Add explicit_struct_names Extension

CHANGELOG.md

@@ -20,6 +20,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Allow `ron::value::RawValue` to capture any whitespace to the left and right of a ron value ([#487](https://github.com/ron-rs/ron/pull/487))
 - Breaking: Enforce that ron always writes valid UTF-8 ([#488](https://github.com/ron-rs/ron/pull/488))
 - Add convenient `Value::from` impls ([#498](https://github.com/ron-rs/ron/pull/498))
+- Add new extension `explicit_struct_names` which requires that struct names are included during deserialization ([#522](https://github.com/ron-rs/ron/pull/522))
 
 ### Format Changes
 

src/error.rs

@@ -110,6 +110,7 @@ pub enum Error {
     SuggestRawIdentifier(String),
     ExpectedRawValue,
     ExceededRecursionLimit,
+    ExpectedStructName(String),
 }
 
 impl fmt::Display for SpannedError {
@@ -281,6 +282,7 @@ impl fmt::Display for Error {
                 "Exceeded recursion limit, try increasing `ron::Options::recursion_limit` \
                 and using `serde_stacker` to protect against a stack overflow",
             ),
+            Error::ExpectedStructName(ref name) => write!(f, "Expected a struct name `{}`, but none was found", name),
         }
     }
 }

src/extensions.rs

@@ -7,6 +7,8 @@ bitflags::bitflags! {
         const UNWRAP_NEWTYPES = 0x1;
         const IMPLICIT_SOME = 0x2;
         const UNWRAP_VARIANT_NEWTYPES = 0x4;
+        /// During deserialization, this extension requires that structs' names are stated explicitly.
+        const EXPLICIT_STRUCT_NAMES = 0x8;
     }
 }
 // GRCOV_EXCL_STOP
@@ -19,6 +21,7 @@ impl Extensions {
             "unwrap_newtypes" => Some(Extensions::UNWRAP_NEWTYPES),
             "implicit_some" => Some(Extensions::IMPLICIT_SOME),
             "unwrap_variant_newtypes" => Some(Extensions::UNWRAP_VARIANT_NEWTYPES),
+            "explicit_struct_names" => Some(Extensions::EXPLICIT_STRUCT_NAMES),
             _ => None,
         }
     }
@@ -40,19 +43,25 @@ mod tests {
         assert_eq!(ext, ext2);
     }
 
+    // todo: maybe make a macro for this?
     #[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::EXPLICIT_STRUCT_NAMES);
         roundtrip_extensions(Extensions::UNWRAP_NEWTYPES | Extensions::IMPLICIT_SOME);
         roundtrip_extensions(Extensions::UNWRAP_NEWTYPES | Extensions::UNWRAP_VARIANT_NEWTYPES);
+        roundtrip_extensions(Extensions::UNWRAP_NEWTYPES | Extensions::EXPLICIT_STRUCT_NAMES);
         roundtrip_extensions(Extensions::IMPLICIT_SOME | Extensions::UNWRAP_VARIANT_NEWTYPES);
+        roundtrip_extensions(Extensions::IMPLICIT_SOME | Extensions::EXPLICIT_STRUCT_NAMES);
+        roundtrip_extensions(Extensions::UNWRAP_VARIANT_NEWTYPES | Extensions::EXPLICIT_STRUCT_NAMES);
         roundtrip_extensions(
             Extensions::UNWRAP_NEWTYPES
                 | Extensions::IMPLICIT_SOME
-                | Extensions::UNWRAP_VARIANT_NEWTYPES,
+                | Extensions::UNWRAP_VARIANT_NEWTYPES
+                | Extensions::EXPLICIT_STRUCT_NAMES,
         );
     }
 }

src/parse.rs

@@ -666,7 +666,11 @@ impl<'a> Parser<'a> {
 
     pub fn consume_struct_name(&mut self, ident: &'static str) -> Result<bool> {
         if self.check_ident("") {
-            return Ok(false);
+            if self.exts.contains(Extensions::EXPLICIT_STRUCT_NAMES) {
+                return Err(Error::ExpectedStructName(ident.to_string()))
+            } else {
+                return Ok(false);
+            }
         }
 
         let found_ident = match self.identifier() {

tests/522_explicit_struct_names.rs

@@ -0,0 +1,43 @@
+use ron::{Options, extensions::Extensions, Error, from_str};
+use serde_derive::Deserialize;
+
+#[derive(Debug, Deserialize)]
+struct Id(u32);
+
+#[derive(Debug, Deserialize)]
+struct Foo {
+    #[allow(unused)]
+    pub id: Id,
+}
+
+const EXPECT_ERROR_MESSAGE: &'static str = "expected `Err(Error::ExpectedStructName)`, deserializer returned `Ok`";
+const INCORRECT_ERROR_MESSAGE: &'static str = "expected error ExpectedStructName, found";
+
+#[test]
+fn explicit_struct_names() {
+    let options = Options::default()
+        .with_default_extension(Extensions::EXPLICIT_STRUCT_NAMES);
+
+    // phase 1
+    let content = r#"(
+        id: Id(3),
+    )"#;
+    let foo = options.from_str::<Foo>(content);
+    match foo.expect_err(EXPECT_ERROR_MESSAGE).code {
+        Error::ExpectedStructName(_) => {},
+        err => panic!("{INCORRECT_ERROR_MESSAGE} \"{err}\""),
+    }
+
+    // phase 2
+    let content = r#"Foo(
+        id: (3),
+    )"#;
+    let foo = options.from_str::<Foo>(content);
+    match foo.expect_err(EXPECT_ERROR_MESSAGE).code {
+        Error::ExpectedStructName(_) => {},
+        err => panic!("{INCORRECT_ERROR_MESSAGE} \"{err}\""),
+    }
+
+    // phase 3 (use content from phase 2)
+    let _foo = from_str::<Foo>(content).unwrap();
+}