Fix DynamicEnum::apply for differing variants

Author: MrGVSV

crates/bevy_reflect/src/enums/dynamic_enum.rs

@@ -280,15 +280,47 @@ impl Reflect for DynamicEnum {
 
     #[inline]
     fn apply(&mut self, value: &dyn Reflect) {
-        if let ReflectRef::Enum(enum_value) = value.reflect_ref() {
-            for field in enum_value.iter_fields() {
-                let name = field.name().unwrap();
-                if let Some(v) = self.field_mut(name) {
-                    v.apply(field.value());
+        if let ReflectRef::Enum(value) = value.reflect_ref() {
+            if Enum::variant_name(self) == value.variant_name() {
+                // Same variant -> just update fields
+                match value.variant_type() {
+                    VariantType::Struct => {
+                        for field in value.iter_fields() {
+                            let name = field.name().unwrap();
+                            Enum::field_mut(self, name).map(|v| v.apply(field.value()));
+                        }
+                    }
+                    VariantType::Tuple => {
+                        for (index, field) in value.iter_fields().enumerate() {
+                            Enum::field_at_mut(self, index).map(|v| v.apply(field.value()));
+                        }
+                    }
+                    _ => {}
                 }
+            } else {
+                // New variant -> perform a switch
+                let dyn_variant = match value.variant_type() {
+                    VariantType::Unit => DynamicVariant::Unit,
+                    VariantType::Tuple => {
+                        let mut dyn_tuple = DynamicTuple::default();
+                        for field in value.iter_fields() {
+                            dyn_tuple.insert_boxed(field.value().clone_value());
+                        }
+                        DynamicVariant::Tuple(dyn_tuple)
+                    }
+                    VariantType::Struct => {
+                        let mut dyn_struct = DynamicStruct::default();
+                        for field in value.iter_fields() {
+                            dyn_struct
+                                .insert_boxed(field.name().unwrap(), field.value().clone_value());
+                        }
+                        DynamicVariant::Struct(dyn_struct)
+                    }
+                };
+                self.set_variant(value.variant_name(), dyn_variant);
             }
         } else {
-            panic!("Attempted to apply non-enum type to enum type.");
+            panic!("`{}` is not an enum", value.type_name());
         }
     }
 

crates/bevy_reflect/src/enums/mod.rs

@@ -127,6 +127,27 @@ mod tests {
         );
     }
 
+    #[test]
+    fn dynamic_enum_should_apply_dynamic_enum() {
+        let mut a = DynamicEnum::from(MyEnum::B(123, 321));
+        let b = DynamicEnum::from(MyEnum::B(123, 321));
+
+        // Sanity check that equality check works
+        assert!(
+            a.reflect_partial_eq(&b).unwrap_or_default(),
+            "dynamic enums should be equal"
+        );
+
+        a.set_variant("A", ());
+        assert!(
+            !a.reflect_partial_eq(&b).unwrap_or_default(),
+            "dynamic enums should not be equal"
+        );
+
+        a.apply(&b);
+        assert!(a.reflect_partial_eq(&b).unwrap_or_default());
+    }
+
     #[test]
     fn dynamic_enum_should_change_variant() {
         let mut value = MyEnum::A;
@@ -429,6 +450,120 @@ mod tests {
         );
     }
 
+    #[test]
+    fn enum_should_apply() {
+        let mut value: Box<dyn Reflect> = Box::new(MyEnum::A);
+
+        // === MyEnum::A -> MyEnum::A === //
+        value.apply(&MyEnum::A);
+        assert!(value.reflect_partial_eq(&MyEnum::A).unwrap_or_default());
+
+        // === MyEnum::A -> MyEnum::B === //
+        value.apply(&MyEnum::B(123, 321));
+        assert!(value
+            .reflect_partial_eq(&MyEnum::B(123, 321))
+            .unwrap_or_default());
+
+        // === MyEnum::B -> MyEnum::B === //
+        value.apply(&MyEnum::B(321, 123));
+        assert!(value
+            .reflect_partial_eq(&MyEnum::B(321, 123))
+            .unwrap_or_default());
+
+        // === MyEnum::B -> MyEnum::C === //
+        value.apply(&MyEnum::C {
+            foo: 1.23,
+            bar: true,
+        });
+        assert!(value
+            .reflect_partial_eq(&MyEnum::C {
+                foo: 1.23,
+                bar: true
+            })
+            .unwrap_or_default());
+
+        // === MyEnum::C -> MyEnum::C === //
+        value.apply(&MyEnum::C {
+            foo: 3.21,
+            bar: false,
+        });
+        assert!(value
+            .reflect_partial_eq(&MyEnum::C {
+                foo: 3.21,
+                bar: false
+            })
+            .unwrap_or_default());
+
+        // === MyEnum::C -> MyEnum::B === //
+        value.apply(&MyEnum::B(123, 321));
+        assert!(value
+            .reflect_partial_eq(&MyEnum::B(123, 321))
+            .unwrap_or_default());
+
+        // === MyEnum::B -> MyEnum::A === //
+        value.apply(&MyEnum::A);
+        assert!(value.reflect_partial_eq(&MyEnum::A).unwrap_or_default());
+    }
+
+    #[test]
+    fn enum_should_set() {
+        let mut value: Box<dyn Reflect> = Box::new(MyEnum::A);
+
+        // === MyEnum::A -> MyEnum::A === //
+        value.set(Box::new(MyEnum::A)).unwrap();
+        assert!(value.reflect_partial_eq(&MyEnum::A).unwrap_or_default());
+
+        // === MyEnum::A -> MyEnum::B === //
+        value.set(Box::new(MyEnum::B(123, 321))).unwrap();
+        assert!(value
+            .reflect_partial_eq(&MyEnum::B(123, 321))
+            .unwrap_or_default());
+
+        // === MyEnum::B -> MyEnum::B === //
+        value.set(Box::new(MyEnum::B(321, 123))).unwrap();
+        assert!(value
+            .reflect_partial_eq(&MyEnum::B(321, 123))
+            .unwrap_or_default());
+
+        // === MyEnum::B -> MyEnum::C === //
+        value
+            .set(Box::new(MyEnum::C {
+                foo: 1.23,
+                bar: true,
+            }))
+            .unwrap();
+        assert!(value
+            .reflect_partial_eq(&MyEnum::C {
+                foo: 1.23,
+                bar: true
+            })
+            .unwrap_or_default());
+
+        // === MyEnum::C -> MyEnum::C === //
+        value
+            .set(Box::new(MyEnum::C {
+                foo: 3.21,
+                bar: false,
+            }))
+            .unwrap();
+        assert!(value
+            .reflect_partial_eq(&MyEnum::C {
+                foo: 3.21,
+                bar: false
+            })
+            .unwrap_or_default());
+
+        // === MyEnum::C -> MyEnum::B === //
+        value.set(Box::new(MyEnum::B(123, 321))).unwrap();
+        assert!(value
+            .reflect_partial_eq(&MyEnum::B(123, 321))
+            .unwrap_or_default());
+
+        // === MyEnum::B -> MyEnum::A === //
+        value.set(Box::new(MyEnum::A)).unwrap();
+        assert!(value.reflect_partial_eq(&MyEnum::A).unwrap_or_default());
+    }
+
     #[test]
     fn enum_should_partial_eq() {
         #[derive(Reflect)]