Objective

Say we have the following code:

#[derive(Reflect)]
#[reflect(from_reflect = false)]
struct TestStruct {
    a: i32,
    b: DynamicStruct,
}

#[derive(Reflect)]
struct OtherStruct {
    c: f32,
}

let my_struct = TestStruct {
    a: 123,
    b: OtherStruct { c: 456.0 }.clone_dynamic(),
};

Using the ReflectSerializer, we can serialize this to get the following output:

{
    "bevy_reflect::serde::tests::TestStruct": (
        a: 123,
        b: (
            c: 456.0,
        ),
    ),
}

However, if we try to deserialize this output, we get hit with an error:

no registration found for type `bevy_reflect::DynamicStruct`

It's understandable why this errors: we can't deserialize the DynamicStruct because we don't know what type it represents...

...or do we?

Solution

This PR makes it so that nested dynamic proxies are serialized as a type map so that we can easily deserialize it back into a dynamic type.

What do I mean by "nested dynamic proxies"? Well, "dynamic proxies" here refers to the fact that these are dynamic types (e.g. DynamicStruct, DynamicArray, etc.) that contain the TypeInfo and structure of a concrete type, thus proxying (or representing) that concrete type.

For example, a DynamicList containing the TypeInfo of Vec<i32> would be a proxy of a Vec<i32>.

And I'm using "nested" to imply that these dynamic types are embedded within another type. Serializing and deserializing a dynamic type as the root already works. It's when the dynamic type is nested as a struct field or list element that it doesn't work.

By serializing a dynamic type as a type map, we give the deserializer knowledge of how to deserialize the dynamic data.

So if we serialize our data again, we get this output:

{
    "bevy_reflect::serde::tests::TestStruct": (
        a: 123,
        b: {
            "bevy_reflect::serde::tests::OtherStruct": (
                c: 456.0,
            ),
        },
    ),
}

With the type information embedded, the deserializer can then know that we need to deserialize a DynamicStruct with the structure of OtherStruct.

Future Work

Originally, I wanted to explore making dynamic types implement FromReflect by simply calling .clone_dynamic() on them.

However, I feel like that would be a lot more controversial (if it even worked), so I thought it would be best to save that for a future PR.

Testing

You can test locally by running:

cargo test --package bevy_reflect

Showcase

You can now serialize and deserialize nested dynamic type data!

#[derive(Reflect)]
#[reflect(from_reflect = false)]
struct TestStruct {
    a: i32,
    // This can only be deserialized if `DynamicStruct`
    // contains the `TypeInfo` of a concrete type
    b: DynamicStruct,
}

#[derive(Reflect)]
struct OtherStruct {
    c: f32,
}

let my_struct = TestStruct {
    a: 123,
    // We use `clone_dynamic` to create the proxy
    // since it internally calls `DynamicStruct::set_represented_type`
    // with the `TypeInfo` of `OtherStruct`
    b: OtherStruct { c: 456.0 }.clone_dynamic(),
};

let serializer = ReflectSerializer::new(&value, &registry);
let output = ron::ser::to_string_pretty(&serializer, Default::default()).unwrap();
// {
//     "bevy_reflect::serde::tests::TestStruct": (
//         a: 123,
//         b: {
//             "bevy_reflect::serde::tests::OtherStruct": (
//                 c: 456.0,
//             ),
//         },
//     ),
// }

let mut deserializer = ron::de::Deserializer::from_str(&output).unwrap();
let reflect_deserializer = ReflectDeserializer::new(&registry);

let result = reflect_deserializer.deserialize(&mut deserializer).unwrap();
assert!(my_struct.reflect_partial_eq(result.as_partial_reflect()).unwrap());

Migration Guide

The serialized representation of dynamic types have changed. Dynamic types will now serialize as a type map rather than just as the type itself.

{
    "my_crate::MyStruct": (
-        dynamic_struct_field: (
-            c: 1.23,
-        ),
+        dynamic_struct_field: {
+            "my_crate::MyOtherStruct": (
+                c: 1.23,
+            ),
+        },
    ),
}

Note that this only affects types where they are strongly-typed as a dynamic type. For example, Vec<MyStruct> would not be affected, but Vec<DynamicTuple> would be affected.