Draft braced structs extension, no tests or special errors yet

juntyr · juntyr · commit 6ca8c1de451b · 2024-11-02T05:48:05.000Z
diff --git a/src/de/mod.rs b/src/de/mod.rs
@@ -176,6 +176,21 @@ impl<'de> Deserializer<'de> {
         let old_serde_content_newtype = self.serde_content_newtype;
         self.serde_content_newtype = false;
 
+        if let Some(ident) = ident {
+            if is_serde_content {
+                // serde's Content type uses a singleton map encoding for enums
+                return visitor.visit_map(SerdeEnumContent {
+                    de: self,
+                    ident: Some(ident),
+                });
+            }
+
+            if self.extensions().contains(Extensions::BRACED_STRUCTS) {
+                // giving no name results in worse errors but is necessary here
+                return self.handle_struct_after_name("", visitor);
+            }
+        }
+
         match (
             self.parser.check_struct_type(
                 NewtypeMode::NoParensMeanUnit,
@@ -192,13 +207,6 @@ impl<'de> Deserializer<'de> {
                 visitor.visit_str(ident)
             }
             (StructType::Unit, _) => visitor.visit_unit(),
-            (_, Some(ident)) if is_serde_content => {
-                // serde's Content type uses a singleton map encoding for enums
-                visitor.visit_map(SerdeEnumContent {
-                    de: self,
-                    ident: Some(ident),
-                })
-            }
             (StructType::Named, _) => {
                 // giving no name results in worse errors but is necessary here
                 self.handle_struct_after_name("", visitor)
@@ -241,7 +249,38 @@ impl<'de> Deserializer<'de> {
     where
         V: Visitor<'de>,
     {
-        if self.newtype_variant || self.parser.consume_char('(') {
+        if self.extensions().contains(Extensions::BRACED_STRUCTS) {
+            self.newtype_variant = false;
+
+            if self.parser.consume_char('{') {
+                let value = guard_recursion! { self =>
+                    visitor
+                        .visit_map(CommaSeparated::new(Terminator::BracedStruct, self))
+                        .map_err(|err| {
+                            struct_error_name(
+                                err,
+                                if !name_for_pretty_errors_only.is_empty() {
+                                    Some(name_for_pretty_errors_only)
+                                } else {
+                                    None
+                                },
+                            )
+                        })?
+                };
+
+                self.parser.skip_ws()?;
+
+                if self.parser.consume_char('}') {
+                    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))
+            }
+        } else if self.newtype_variant || self.parser.consume_char('(') {
             let old_newtype_variant = self.newtype_variant;
             self.newtype_variant = false;
 
@@ -719,6 +758,10 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
     where
         V: Visitor<'de>,
     {
+        if self.extensions().contains(Extensions::BRACED_STRUCTS) {
+            self.newtype_variant = false;
+        }
+
         if !self.newtype_variant {
             self.parser.consume_struct_name(name)?;
         }
@@ -778,13 +821,14 @@ enum Terminator {
     MapAsStruct,
     Tuple,
     Struct,
+    BracedStruct,
     Seq,
 }
 
 impl Terminator {
     fn as_char(&self) -> char {
         match self {
-            Terminator::Map | Terminator::MapAsStruct => '}',
+            Terminator::Map | Terminator::MapAsStruct | Terminator::BracedStruct => '}',
             Terminator::Tuple | Terminator::Struct => ')',
             Terminator::Seq => ']',
         }
@@ -856,7 +900,7 @@ impl<'de, 'a> de::MapAccess<'de> for CommaSeparated<'a, 'de> {
                 std::any::type_name::<K::Value>() == SERDE_TAG_KEY_CANARY;
 
             match self.terminator {
-                Terminator::Struct => guard_recursion! { self.de =>
+                Terminator::Struct | Terminator::BracedStruct => guard_recursion! { self.de =>
                     seed.deserialize(&mut id::Deserializer::new(&mut *self.de, false)).map(Some)
                 },
                 Terminator::MapAsStruct => guard_recursion! { self.de =>
diff --git a/src/extensions.rs b/src/extensions.rs
@@ -11,6 +11,7 @@ bitflags::bitflags! {
         ///
         /// During deserialization, this extension requires that structs' names are stated explicitly.
         const EXPLICIT_STRUCT_NAMES = 0x8;
+        const BRACED_STRUCTS = 0x10;
     }
 }
 // GRCOV_EXCL_STOP
diff --git a/src/parse.rs b/src/parse.rs
@@ -572,7 +572,17 @@ impl<'a> Parser<'a> {
 
                 match parser.peek_char() {
                     // Definitely a struct with named fields
-                    Some(':') => return Ok(StructType::Named),
+                    Some(':') => {
+                        if parser.exts.contains(Extensions::BRACED_STRUCTS) {
+                            return Err(Error::ExpectedStructLike);
+                        } else {
+                            return Ok(StructType::Named);
+                        }
+                    }
+                    // Definitely a braced struct with named fields
+                    Some('{') if parser.exts.contains(Extensions::BRACED_STRUCTS) => {
+                        return Ok(StructType::Named)
+                    }
                     // Definitely a tuple-like struct with fields
                     Some(',') => {
                         parser.skip_next_char();
@@ -668,7 +678,9 @@ impl<'a> Parser<'a> {
 
     pub fn consume_struct_name(&mut self, ident: &'static str) -> Result<bool> {
         if self.check_ident("") {
-            if self.exts.contains(Extensions::EXPLICIT_STRUCT_NAMES) {
+            if self.exts.contains(Extensions::EXPLICIT_STRUCT_NAMES)
+                || self.exts.contains(Extensions::BRACED_STRUCTS)
+            {
                 return Err(Error::ExpectedStructName(ident.to_string()));
             }
 
diff --git a/src/ser/mod.rs b/src/ser/mod.rs
@@ -946,25 +946,28 @@ impl<'a, W: fmt::Write> ser::Serializer for &'a mut Serializer<W> {
             self.start_indent()?;
         }
 
-        Ok(Compound::new(self, false))
+        Ok(Compound::new(self, Some(']')))
     }
 
     fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple> {
         let old_newtype_variant = self.newtype_variant;
         self.newtype_variant = false;
         self.implicit_some_depth = 0;
 
-        if !old_newtype_variant {
+        let closing = if old_newtype_variant {
+            None
+        } else {
             self.output.write_char('(')?;
-        }
+            Some(')')
+        };
 
         if self.separate_tuple_members() {
             self.is_empty = Some(len == 0);
 
             self.start_indent()?;
         }
 
-        Ok(Compound::new(self, old_newtype_variant))
+        Ok(Compound::new(self, closing))
     }
 
     fn serialize_tuple_struct(
@@ -1001,7 +1004,7 @@ impl<'a, W: fmt::Write> ser::Serializer for &'a mut Serializer<W> {
             self.start_indent()?;
         }
 
-        Ok(Compound::new(self, false))
+        Ok(Compound::new(self, Some(')')))
     }
 
     fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap> {
@@ -1018,31 +1021,37 @@ impl<'a, W: fmt::Write> ser::Serializer for &'a mut Serializer<W> {
             self.start_indent()?;
         }
 
-        Ok(Compound::new(self, false))
+        Ok(Compound::new(self, Some('}')))
     }
 
     fn serialize_struct(self, name: &'static str, len: usize) -> Result<Self::SerializeStruct> {
         let old_newtype_variant = self.newtype_variant;
         self.newtype_variant = false;
         self.implicit_some_depth = 0;
 
-        if old_newtype_variant {
+        let closing = if self.extensions().contains(Extensions::BRACED_STRUCTS) {
+            self.write_identifier(name)?;
+            self.output.write_char('{')?;
+            Some('}')
+        } else if old_newtype_variant {
             self.validate_identifier(name)?;
+            None
         } else {
             if self.struct_names() {
                 self.write_identifier(name)?;
             } else {
                 self.validate_identifier(name)?;
             }
             self.output.write_char('(')?;
-        }
+            Some(')')
+        };
 
         if !self.compact_structs() {
             self.is_empty = Some(len == 0);
             self.start_indent()?;
         }
 
-        Ok(Compound::new(self, old_newtype_variant))
+        Ok(Compound::new(self, closing))
     }
 
     fn serialize_struct_variant(
@@ -1057,14 +1066,21 @@ impl<'a, W: fmt::Write> ser::Serializer for &'a mut Serializer<W> {
 
         self.validate_identifier(name)?;
         self.write_identifier(variant)?;
-        self.output.write_char('(')?;
+
+        let closing = if self.extensions().contains(Extensions::BRACED_STRUCTS) {
+            self.output.write_char('{')?;
+            '}'
+        } else {
+            self.output.write_char('(')?;
+            ')'
+        };
 
         if !self.compact_structs() {
             self.is_empty = Some(len == 0);
             self.start_indent()?;
         }
 
-        Ok(Compound::new(self, false))
+        Ok(Compound::new(self, Some(closing)))
     }
 }
 
@@ -1077,16 +1093,16 @@ enum State {
 pub struct Compound<'a, W: fmt::Write> {
     ser: &'a mut Serializer<W>,
     state: State,
-    newtype_variant: bool,
+    closing: Option<char>,
     sequence_index: usize,
 }
 
 impl<'a, W: fmt::Write> Compound<'a, W> {
-    fn new(ser: &'a mut Serializer<W>, newtype_variant: bool) -> Self {
+    fn new(ser: &'a mut Serializer<W>, closing: Option<char>) -> Self {
         Compound {
             ser,
             state: State::First,
-            newtype_variant,
+            closing,
             sequence_index: 0,
         }
     }
@@ -1151,8 +1167,10 @@ impl<'a, W: fmt::Write> ser::SerializeSeq for Compound<'a, W> {
             self.ser.end_indent()?;
         }
 
-        // seq always disables `self.newtype_variant`
-        self.ser.output.write_char(']')?;
+        if let Some(closing) = self.closing {
+            self.ser.output.write_char(closing)?;
+        }
+
         Ok(())
     }
 }
@@ -1200,8 +1218,8 @@ impl<'a, W: fmt::Write> ser::SerializeTuple for Compound<'a, W> {
             self.ser.end_indent()?;
         }
 
-        if !self.newtype_variant {
-            self.ser.output.write_char(')')?;
+        if let Some(closing) = self.closing {
+            self.ser.output.write_char(closing)?;
         }
 
         Ok(())
@@ -1299,8 +1317,10 @@ impl<'a, W: fmt::Write> ser::SerializeMap for Compound<'a, W> {
             self.ser.end_indent()?;
         }
 
-        // map always disables `self.newtype_variant`
-        self.ser.output.write_char('}')?;
+        if let Some(closing) = self.closing {
+            self.ser.output.write_char(closing)?;
+        }
+
         Ok(())
     }
 }
@@ -1357,9 +1377,10 @@ impl<'a, W: fmt::Write> ser::SerializeStruct for Compound<'a, W> {
             self.ser.end_indent()?;
         }
 
-        if !self.newtype_variant {
-            self.ser.output.write_char(')')?;
+        if let Some(closing) = self.closing {
+            self.ser.output.write_char(closing)?;
         }
+
         Ok(())
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -11,6 +11,7 @@ bitflags::bitflags! {`
`11`	`11`	`///`
`12`	`12`	`/// During deserialization, this extension requires that structs' names are stated explicitly.`
`13`	`13`	`const EXPLICIT_STRUCT_NAMES = 0x8;`
	`14`	`+ const BRACED_STRUCTS = 0x10;`
`14`	`15`	`}`
`15`	`16`	`}`
`16`	`17`	`// GRCOV_EXCL_STOP`
Original file line number	Diff line number	Diff line change
`@@ -946,25 +946,28 @@ impl<'a, W: fmt::Write> ser::Serializer for &'a mut Serializer<W> {`
`946`	`946`	`self.start_indent()?;`
`947`	`947`	`}`
`948`	`948`
`949`		`- Ok(Compound::new(self, false))`
	`949`	`+ Ok(Compound::new(self, Some(']')))`
`950`	`950`	`}`
`951`	`951`
`952`	`952`	`fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple> {`
`953`	`953`	`let old_newtype_variant = self.newtype_variant;`
`954`	`954`	`self.newtype_variant = false;`
`955`	`955`	`self.implicit_some_depth = 0;`
`956`	`956`
`957`		`- if !old_newtype_variant {`
	`957`	`+ let closing = if old_newtype_variant {`
	`958`	`+ None`
	`959`	`+ } else {`
`958`	`960`	`self.output.write_char('(')?;`
`959`		`- }`
	`961`	`+ Some(')')`
	`962`	`+ };`
`960`	`963`
`961`	`964`	`if self.separate_tuple_members() {`
`962`	`965`	`self.is_empty = Some(len == 0);`
`963`	`966`
`964`	`967`	`self.start_indent()?;`
`965`	`968`	`}`
`966`	`969`
`967`		`- Ok(Compound::new(self, old_newtype_variant))`
	`970`	`+ Ok(Compound::new(self, closing))`
`968`	`971`	`}`
`969`	`972`
`970`	`973`	`fn serialize_tuple_struct(`
`@@ -1001,7 +1004,7 @@ impl<'a, W: fmt::Write> ser::Serializer for &'a mut Serializer<W> {`
`1001`	`1004`	`self.start_indent()?;`
`1002`	`1005`	`}`
`1003`	`1006`
`1004`		`- Ok(Compound::new(self, false))`
	`1007`	`+ Ok(Compound::new(self, Some(')')))`
`1005`	`1008`	`}`
`1006`	`1009`
`1007`	`1010`	`fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap> {`
`@@ -1018,31 +1021,37 @@ impl<'a, W: fmt::Write> ser::Serializer for &'a mut Serializer<W> {`
`1018`	`1021`	`self.start_indent()?;`
`1019`	`1022`	`}`
`1020`	`1023`
`1021`		`- Ok(Compound::new(self, false))`
	`1024`	`+ Ok(Compound::new(self, Some('}')))`
`1022`	`1025`	`}`
`1023`	`1026`
`1024`	`1027`	`fn serialize_struct(self, name: &'static str, len: usize) -> Result<Self::SerializeStruct> {`
`1025`	`1028`	`let old_newtype_variant = self.newtype_variant;`
`1026`	`1029`	`self.newtype_variant = false;`
`1027`	`1030`	`self.implicit_some_depth = 0;`
`1028`	`1031`
`1029`		`- if old_newtype_variant {`
	`1032`	`+ let closing = if self.extensions().contains(Extensions::BRACED_STRUCTS) {`
	`1033`	`+ self.write_identifier(name)?;`
	`1034`	`+ self.output.write_char('{')?;`
	`1035`	`+ Some('}')`
	`1036`	`+ } else if old_newtype_variant {`
`1030`	`1037`	`self.validate_identifier(name)?;`
	`1038`	`+ None`
`1031`	`1039`	`} else {`
`1032`	`1040`	`if self.struct_names() {`
`1033`	`1041`	`self.write_identifier(name)?;`
`1034`	`1042`	`} else {`
`1035`	`1043`	`self.validate_identifier(name)?;`
`1036`	`1044`	`}`
`1037`	`1045`	`self.output.write_char('(')?;`
`1038`		`- }`
	`1046`	`+ Some(')')`
	`1047`	`+ };`
`1039`	`1048`
`1040`	`1049`	`if !self.compact_structs() {`
`1041`	`1050`	`self.is_empty = Some(len == 0);`
`1042`	`1051`	`self.start_indent()?;`
`1043`	`1052`	`}`
`1044`	`1053`
`1045`		`- Ok(Compound::new(self, old_newtype_variant))`
	`1054`	`+ Ok(Compound::new(self, closing))`
`1046`	`1055`	`}`
`1047`	`1056`
`1048`	`1057`	`fn serialize_struct_variant(`
`@@ -1057,14 +1066,21 @@ impl<'a, W: fmt::Write> ser::Serializer for &'a mut Serializer<W> {`
`1057`	`1066`
`1058`	`1067`	`self.validate_identifier(name)?;`
`1059`	`1068`	`self.write_identifier(variant)?;`
`1060`		`- self.output.write_char('(')?;`
	`1069`	`+`
	`1070`	`+ let closing = if self.extensions().contains(Extensions::BRACED_STRUCTS) {`
	`1071`	`+ self.output.write_char('{')?;`
	`1072`	`+ '}'`
	`1073`	`+ } else {`
	`1074`	`+ self.output.write_char('(')?;`
	`1075`	`+ ')'`
	`1076`	`+ };`
`1061`	`1077`
`1062`	`1078`	`if !self.compact_structs() {`
`1063`	`1079`	`self.is_empty = Some(len == 0);`
`1064`	`1080`	`self.start_indent()?;`
`1065`	`1081`	`}`
`1066`	`1082`
`1067`		`- Ok(Compound::new(self, false))`
	`1083`	`+ Ok(Compound::new(self, Some(closing)))`
`1068`	`1084`	`}`
`1069`	`1085`	`}`
`1070`	`1086`
`@@ -1077,16 +1093,16 @@ enum State {`
`1077`	`1093`	`pub struct Compound<'a, W: fmt::Write> {`
`1078`	`1094`	`ser: &'a mut Serializer<W>,`
`1079`	`1095`	`state: State,`
`1080`		`- newtype_variant: bool,`
	`1096`	`+ closing: Option<char>,`
`1081`	`1097`	`sequence_index: usize,`
`1082`	`1098`	`}`
`1083`	`1099`
`1084`	`1100`	`impl<'a, W: fmt::Write> Compound<'a, W> {`
`1085`		`- fn new(ser: &'a mut Serializer<W>, newtype_variant: bool) -> Self {`
	`1101`	`+ fn new(ser: &'a mut Serializer<W>, closing: Option<char>) -> Self {`
`1086`	`1102`	`Compound {`
`1087`	`1103`	`ser,`
`1088`	`1104`	`state: State::First,`
`1089`		`- newtype_variant,`
	`1105`	`+ closing,`
`1090`	`1106`	`sequence_index: 0,`
`1091`	`1107`	`}`
`1092`	`1108`	`}`
`@@ -1151,8 +1167,10 @@ impl<'a, W: fmt::Write> ser::SerializeSeq for Compound<'a, W> {`
`1151`	`1167`	`self.ser.end_indent()?;`
`1152`	`1168`	`}`
`1153`	`1169`
`1154`		- // seq always disables `self.newtype_variant`
`1155`		`- self.ser.output.write_char(']')?;`
	`1170`	`+ if let Some(closing) = self.closing {`
	`1171`	`+ self.ser.output.write_char(closing)?;`
	`1172`	`+ }`
	`1173`	`+`
`1156`	`1174`	`Ok(())`
`1157`	`1175`	`}`
`1158`	`1176`	`}`
`@@ -1200,8 +1218,8 @@ impl<'a, W: fmt::Write> ser::SerializeTuple for Compound<'a, W> {`
`1200`	`1218`	`self.ser.end_indent()?;`
`1201`	`1219`	`}`
`1202`	`1220`
`1203`		`- if !self.newtype_variant {`
`1204`		`- self.ser.output.write_char(')')?;`
	`1221`	`+ if let Some(closing) = self.closing {`
	`1222`	`+ self.ser.output.write_char(closing)?;`
`1205`	`1223`	`}`
`1206`	`1224`
`1207`	`1225`	`Ok(())`
`@@ -1299,8 +1317,10 @@ impl<'a, W: fmt::Write> ser::SerializeMap for Compound<'a, W> {`
`1299`	`1317`	`self.ser.end_indent()?;`
`1300`	`1318`	`}`
`1301`	`1319`
`1302`		- // map always disables `self.newtype_variant`
`1303`		`- self.ser.output.write_char('}')?;`
	`1320`	`+ if let Some(closing) = self.closing {`
	`1321`	`+ self.ser.output.write_char(closing)?;`
	`1322`	`+ }`
	`1323`	`+`
`1304`	`1324`	`Ok(())`
`1305`	`1325`	`}`
`1306`	`1326`	`}`
`@@ -1357,9 +1377,10 @@ impl<'a, W: fmt::Write> ser::SerializeStruct for Compound<'a, W> {`
`1357`	`1377`	`self.ser.end_indent()?;`
`1358`	`1378`	`}`
`1359`	`1379`
`1360`		`- if !self.newtype_variant {`
`1361`		`- self.ser.output.write_char(')')?;`
	`1380`	`+ if let Some(closing) = self.closing {`
	`1381`	`+ self.ser.output.write_char(closing)?;`
`1362`	`1382`	`}`
	`1383`	`+`
`1363`	`1384`	`Ok(())`
`1364`	`1385`	`}`
`1365`	`1386`	`}`