Remove "type" and "value" keys

MrGVSV · MrGVSV · commit 92e08ec626ac · 2022-08-07T17:31:45.000-07:00
Replaced with "type" key with the actual type name
diff --git a/crates/bevy_reflect/src/lib.rs b/crates/bevy_reflect/src/lib.rs
@@ -942,8 +942,7 @@ bevy_reflect::tests::should_reflect_debug::Test {
             let output = to_string_pretty(&ser, config).unwrap();
             let expected = r#"
 {
-    "type": "glam::f32::vec3::Vec3",
-    "value": {
+    "glam::f32::vec3::Vec3": {
         "x": 12.0,
         "y": 3.0,
         "z": -6.9,
@@ -957,8 +956,7 @@ bevy_reflect::tests::should_reflect_debug::Test {
         fn vec3_deserialization() {
             let data = r#"
 {
-    "type": "glam::f32::vec3::Vec3",
-    "value": {
+    "glam::f32::vec3::Vec3": {
         "x": 12.0,
         "y": 3.0,
         "z": -6.9,
diff --git a/crates/bevy_reflect/src/serde/de.rs b/crates/bevy_reflect/src/serde/de.rs
@@ -1,8 +1,8 @@
 use crate::{
-    serde::type_fields, ArrayInfo, DynamicArray, DynamicEnum, DynamicList, DynamicMap,
-    DynamicStruct, DynamicTuple, DynamicTupleStruct, EnumInfo, ListInfo, Map, MapInfo, NamedField,
-    Reflect, ReflectDeserialize, StructInfo, StructVariantInfo, Tuple, TupleInfo, TupleStruct,
-    TupleStructInfo, TupleVariantInfo, TypeInfo, TypeRegistry, UnnamedField, VariantInfo,
+    ArrayInfo, DynamicArray, DynamicEnum, DynamicList, DynamicMap, DynamicStruct, DynamicTuple,
+    DynamicTupleStruct, EnumInfo, ListInfo, Map, MapInfo, NamedField, Reflect, ReflectDeserialize,
+    StructInfo, StructVariantInfo, Tuple, TupleInfo, TupleStruct, TupleStructInfo,
+    TupleVariantInfo, TypeInfo, TypeRegistry, UnnamedField, VariantInfo,
 };
 use erased_serde::Deserializer;
 use serde::de::{self, DeserializeSeed, Error, MapAccess, SeqAccess, Visitor};
@@ -137,42 +137,19 @@ impl<'a, 'de> Visitor<'de> for UntypedReflectDeserializerVisitor<'a> {
     where
         A: MapAccess<'de>,
     {
-        let type_name = match map.next_key::<&str>()? {
-            Some(type_fields::TYPE) => map.next_value::<&str>()?,
-            Some(type_fields::VALUE) => {
-                // `type` must come before `value`.
-                return Err(de::Error::missing_field(type_fields::TYPE));
-            }
-            Some(field) => {
-                return Err(de::Error::unknown_field(field, &[type_fields::TYPE]));
-            }
-            None => {
-                return Err(de::Error::invalid_length(
-                    0,
-                    &"two entries: `type` and `value`",
-                ));
-            }
-        };
+        let type_name = map
+            .next_key::<&str>()?
+            .ok_or_else(|| Error::invalid_length(0, &"at least one entry"))?;
 
-        match map.next_key::<&str>()? {
-            Some(type_fields::VALUE) => {
-                let registration = self.registry.get_with_name(type_name).ok_or_else(|| {
-                    de::Error::custom(format_args!("No registration found for {}", type_name))
-                })?;
-                let type_info = registration.type_info();
-                let value = map.next_value_seed(TypedReflectDeserializer {
-                    type_info,
-                    registry: self.registry,
-                })?;
-                Ok(value)
-            }
-            Some(type_fields::TYPE) => Err(de::Error::duplicate_field(type_fields::TYPE)),
-            Some(field) => Err(de::Error::unknown_field(field, &[type_fields::VALUE])),
-            None => Err(de::Error::invalid_length(
-                0,
-                &"two entries: `type` and `value`",
-            )),
-        }
+        let registration = self.registry.get_with_name(type_name).ok_or_else(|| {
+            Error::custom(format_args!("No registration found for {}", type_name))
+        })?;
+        let type_info = registration.type_info();
+        let value = map.next_value_seed(TypedReflectDeserializer {
+            type_info,
+            registry: self.registry,
+        })?;
+        Ok(value)
     }
 }
 
@@ -397,8 +374,8 @@ impl<'a, 'de> Visitor<'de> for TupleVisitor<'a> {
     }
 
     fn visit_seq<V>(self, mut seq: V) -> Result<Self::Value, V::Error>
-        where
-            V: SeqAccess<'de>,
+    where
+        V: SeqAccess<'de>,
     {
         visit_tuple(&mut seq, self.tuple_info, self.registry)
     }
@@ -819,8 +796,7 @@ mod tests {
 
         // === Unit Variant === //
         let input = r#"{
-            "type": "bevy_reflect::serde::de::tests::enum_should_deserialize::MyEnum",
-            "value": {
+            "bevy_reflect::serde::de::tests::enum_should_deserialize::MyEnum": {
                 "Unit": (),
             },
         }"#;
@@ -833,8 +809,7 @@ mod tests {
 
         // === NewType Variant === //
         let input = r#"{
-            "type": "bevy_reflect::serde::de::tests::enum_should_deserialize::MyEnum",
-            "value": {
+            "bevy_reflect::serde::de::tests::enum_should_deserialize::MyEnum": {
                 "NewType": (123),
             },
         }"#;
@@ -847,8 +822,7 @@ mod tests {
 
         // === Tuple Variant === //
         let input = r#"{
-            "type": "bevy_reflect::serde::de::tests::enum_should_deserialize::MyEnum",
-            "value": {
+            "bevy_reflect::serde::de::tests::enum_should_deserialize::MyEnum": {
                 "Tuple": (1.23, 3.21),
             },
         }"#;
@@ -861,8 +835,7 @@ mod tests {
 
         // === Struct Variant === //
         let input = r#"{
-            "type": "bevy_reflect::serde::de::tests::enum_should_deserialize::MyEnum",
-            "value": {
+            "bevy_reflect::serde::de::tests::enum_should_deserialize::MyEnum": {
                 "Struct": {
                     "value": "I <3 Enums",
                 },
@@ -899,8 +872,7 @@ mod tests {
         };
 
         let input = r#"{
-            "type": "bevy_reflect::serde::de::tests::MyStruct",
-            "value": {
+            "bevy_reflect::serde::de::tests::MyStruct": {
                 "primitive_value": 123,
                 "option_value": Some("Hello world!"),
                 "tuple_value": (
@@ -951,8 +923,7 @@ mod tests {
     #[test]
     fn should_deserialize_value() {
         let input = r#"{
-            "type": "f32",
-            "value": 1.23,
+            "f32": 1.23,
         }"#;
 
         let registry = get_registry();
diff --git a/crates/bevy_reflect/src/serde/mod.rs b/crates/bevy_reflect/src/serde/mod.rs
@@ -3,8 +3,3 @@ mod ser;
 
 pub use de::*;
 pub use ser::*;
-
-pub(crate) mod type_fields {
-    pub const TYPE: &str = "type";
-    pub const VALUE: &str = "value";
-}
diff --git a/crates/bevy_reflect/src/serde/ser.rs b/crates/bevy_reflect/src/serde/ser.rs
@@ -1,6 +1,6 @@
 use crate::{
-    serde::type_fields, Array, Enum, List, Map, Reflect, ReflectRef, ReflectSerialize, Struct,
-    Tuple, TupleStruct, TypeRegistry, VariantType,
+    Array, Enum, List, Map, Reflect, ReflectRef, ReflectSerialize, Struct, Tuple, TupleStruct,
+    TypeRegistry, VariantType,
 };
 use serde::ser::SerializeTuple;
 use serde::{
@@ -61,10 +61,9 @@ impl<'a> Serialize for ReflectSerializer<'a> {
     where
         S: serde::Serializer,
     {
-        let mut state = serializer.serialize_map(Some(2))?;
-        state.serialize_entry(type_fields::TYPE, self.value.type_name())?;
+        let mut state = serializer.serialize_map(Some(1))?;
         state.serialize_entry(
-            type_fields::VALUE,
+            self.value.type_name(),
             &TypedReflectSerializer::new(self.value, self.registry),
         )?;
         state.end()
@@ -442,8 +441,7 @@ mod tests {
 
         let output = ron::ser::to_string_pretty(&serializer, config).unwrap();
         let expected = r#"{
-    "type": "bevy_reflect::serde::ser::tests::MyStruct",
-    "value": {
+    "bevy_reflect::serde::ser::tests::MyStruct": {
         "primitive_value": 123,
         "option_value": Some("Hello world!"),
         "tuple_value": (3.1415927, 1337),
@@ -493,8 +491,7 @@ mod tests {
         let serializer = ReflectSerializer::new(&value, &registry);
         let output = ron::ser::to_string_pretty(&serializer, config.clone()).unwrap();
         let expected = r#"{
-    "type": "bevy_reflect::serde::ser::tests::enum_should_serialize::MyEnum",
-    "value": {
+    "bevy_reflect::serde::ser::tests::enum_should_serialize::MyEnum": {
         "Unit": (),
     },
 }"#;
@@ -505,8 +502,7 @@ mod tests {
         let serializer = ReflectSerializer::new(&value, &registry);
         let output = ron::ser::to_string_pretty(&serializer, config.clone()).unwrap();
         let expected = r#"{
-    "type": "bevy_reflect::serde::ser::tests::enum_should_serialize::MyEnum",
-    "value": {
+    "bevy_reflect::serde::ser::tests::enum_should_serialize::MyEnum": {
         "NewType": (123),
     },
 }"#;
@@ -517,8 +513,7 @@ mod tests {
         let serializer = ReflectSerializer::new(&value, &registry);
         let output = ron::ser::to_string_pretty(&serializer, config.clone()).unwrap();
         let expected = r#"{
-    "type": "bevy_reflect::serde::ser::tests::enum_should_serialize::MyEnum",
-    "value": {
+    "bevy_reflect::serde::ser::tests::enum_should_serialize::MyEnum": {
         "Tuple": (1.23, 3.21),
     },
 }"#;
@@ -531,8 +526,7 @@ mod tests {
         let serializer = ReflectSerializer::new(&value, &registry);
         let output = ron::ser::to_string_pretty(&serializer, config).unwrap();
         let expected = r#"{
-    "type": "bevy_reflect::serde::ser::tests::enum_should_serialize::MyEnum",
-    "value": {
+    "bevy_reflect::serde::ser::tests::enum_should_serialize::MyEnum": {
         "Struct": {
             "value": "I <3 Enums",
         },
