Fix List::push by requiring Default

Author: Davier

crates/bevy_ecs/src/entity/mod.rs

@@ -77,6 +77,12 @@ impl fmt::Debug for Entity {
     }
 }
 
+impl Default for Entity {
+    fn default() -> Self {
+        Self::new(u32::MAX)
+    }
+}
+
 impl SparseSetIndex for Entity {
     fn sparse_set_index(&self) -> usize {
         self.id() as usize

crates/bevy_reflect/src/impls/smallvec.rs

@@ -5,7 +5,7 @@ use crate::{serde::Serializable, List, ListIter, Reflect, ReflectMut, ReflectRef
 
 impl<T: Array + Send + Sync + 'static> List for SmallVec<T>
 where
-    T::Item: Reflect + Clone,
+    T::Item: Reflect + Clone + Default,
 {
     fn get(&self, index: usize) -> Option<&dyn Reflect> {
         if index < SmallVec::len(self) {
@@ -29,10 +29,10 @@ where
 
     fn push(&mut self, value: Box<dyn Reflect>) {
         let value = value.take::<T::Item>().unwrap_or_else(|value| {
-            panic!(
-                "Attempted to push invalid value of type {}.",
-                value.type_name()
-            )
+            // If `value` is not of the same type, it may be a dynamic type that needs to be applied
+            let mut new_value = T::Item::default();
+            (&mut new_value as &mut dyn Reflect).apply(value.as_ref());
+            new_value
         });
         SmallVec::push(self, value);
     }
@@ -48,7 +48,7 @@ where
 // SAFE: any and any_mut both return self
 unsafe impl<T: Array + Send + Sync + 'static> Reflect for SmallVec<T>
 where
-    T::Item: Reflect + Clone,
+    T::Item: Reflect + Clone + Default,
 {
     fn type_name(&self) -> &str {
         std::any::type_name::<Self>()

crates/bevy_reflect/src/impls/std.rs

@@ -35,7 +35,7 @@ impl_reflect_value!(HashSet<T: Serialize + Hash + Eq + Clone + for<'de> Deserial
 impl_reflect_value!(Range<T: Serialize + Clone + for<'de> Deserialize<'de> + Send + Sync + 'static>(Serialize, Deserialize));
 impl_reflect_value!(Duration);
 
-impl<T: Reflect> List for Vec<T> {
+impl<T: Reflect + Default> List for Vec<T> {
     fn get(&self, index: usize) -> Option<&dyn Reflect> {
         <[T]>::get(self, index).map(|value| value as &dyn Reflect)
     }
@@ -57,17 +57,17 @@ impl<T: Reflect> List for Vec<T> {
 
     fn push(&mut self, value: Box<dyn Reflect>) {
         let value = value.take::<T>().unwrap_or_else(|value| {
-            panic!(
-                "Attempted to push invalid value of type {}.",
-                value.type_name()
-            )
+            // If `value` is not of the same type, it may be a dynamic type that needs to be applied
+            let mut new_value = T::default();
+            (&mut new_value as &mut dyn Reflect).apply(value.as_ref());
+            new_value
         });
         Vec::push(self, value);
     }
 }
 
 // SAFE: any and any_mut both return self
-unsafe impl<T: Reflect> Reflect for Vec<T> {
+unsafe impl<T: Reflect + Default> Reflect for Vec<T> {
     fn type_name(&self) -> &str {
         std::any::type_name::<Self>()
     }
@@ -114,7 +114,7 @@ unsafe impl<T: Reflect> Reflect for Vec<T> {
     }
 }
 
-impl<T: Reflect + for<'de> Deserialize<'de>> GetTypeRegistration for Vec<T> {
+impl<T: Reflect + Default + for<'de> Deserialize<'de>> GetTypeRegistration for Vec<T> {
     fn get_type_registration() -> TypeRegistration {
         let mut registration = TypeRegistration::of::<Vec<T>>();
         registration.insert::<ReflectDeserialize>(FromType::<Vec<T>>::from_type());

crates/bevy_reflect/src/path.rs

@@ -326,7 +326,7 @@ mod tests {
             bar: C,
         }
 
-        #[derive(Reflect)]
+        #[derive(Reflect, Default)]
         struct C {
             baz: f32,
         }

crates/bevy_transform/src/components/parent.rs

@@ -6,20 +6,10 @@ use bevy_ecs::{
 use bevy_reflect::Reflect;
 use std::ops::{Deref, DerefMut};
 
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Reflect)]
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Reflect, Default)]
 #[reflect(Component, MapEntities, PartialEq)]
 pub struct Parent(pub Entity);
 
-// TODO: We need to impl either FromWorld or Default so Parent can be registered as Properties.
-// This is because Properties deserialize by creating an instance and apply a patch on top.
-// However Parent should only ever be set with a real user-defined entity.  Its worth looking into
-// better ways to handle cases like this.
-impl FromWorld for Parent {
-    fn from_world(_world: &mut World) -> Self {
-        Parent(Entity::new(u32::MAX))
-    }
-}
-
 impl MapEntities for Parent {
     fn map_entities(&mut self, entity_map: &EntityMap) -> Result<(), MapEntitiesError> {
         self.0 = entity_map.get(self.0)?;