Removed the Struct stuff,, just the Dynamic Struct removal methods now

Author: Diddykonga

crates/bevy_ecs/src/reflect/bundle.rs

@@ -166,7 +166,7 @@ impl<B: Bundle + Reflect + TypePath + BundleFromComponents> FromType<B> for Refl
                     match reflected_bundle.reflect_ref() {
                         ReflectRef::Struct(bundle) => bundle
                             .iter_fields()
-                            .for_each(|(_, field)| apply_field(&mut entity, field, registry)),
+                            .for_each(|field| apply_field(&mut entity, field, registry)),
                         ReflectRef::Tuple(bundle) => bundle
                             .iter_fields()
                             .for_each(|field| apply_field(&mut entity, field, registry)),
@@ -195,17 +195,15 @@ impl<B: Bundle + Reflect + TypePath + BundleFromComponents> FromType<B> for Refl
                     );
                 } else {
                     match reflected_bundle.reflect_ref() {
-                        ReflectRef::Struct(bundle) => {
-                            bundle.iter_fields().for_each(|(_, field)| {
-                                apply_or_insert_field_mapped(
-                                    entity,
-                                    field,
-                                    registry,
-                                    mapper,
-                                    relationship_hook_mode,
-                                );
-                            });
-                        }
+                        ReflectRef::Struct(bundle) => bundle.iter_fields().for_each(|field| {
+                            apply_or_insert_field_mapped(
+                                entity,
+                                field,
+                                registry,
+                                mapper,
+                                relationship_hook_mode,
+                            );
+                        }),
                         ReflectRef::Tuple(bundle) => bundle.iter_fields().for_each(|field| {
                             apply_or_insert_field_mapped(
                                 entity,

crates/bevy_reflect/derive/src/impls/structs.rs

@@ -115,23 +115,6 @@ pub(crate) fn impl_struct(reflect_struct: &ReflectStruct) -> proc_macro2::TokenS
                 }
             }
 
-            fn name_of(&self, field: &dyn #bevy_reflect_path::PartialReflect) -> #FQOption<&str> {
-               #(if ::core::ptr::addr_eq(#fields_ref, field) { return #fqoption::Some(#field_names) })*
-                #FQOption::None
-            }
-
-            fn index_of(&self, field: &dyn #bevy_reflect_path::PartialReflect) -> #FQOption<usize> {
-                #(if ::core::ptr::addr_eq(#fields_ref, field) { return #fqoption::Some(#field_indices) })*
-                #FQOption::None
-            }
-
-            fn index_of_name(&self, name: &str) -> #FQOption<usize> {
-                match name {
-                    #(#field_names => #fqoption::Some(#field_indices),)*
-                    _ => #FQOption::None,
-                }
-            }
-
             fn field_len(&self) -> usize {
                 #field_count
             }
@@ -161,7 +144,8 @@ pub(crate) fn impl_struct(reflect_struct: &ReflectStruct) -> proc_macro2::TokenS
             ) -> #FQResult<(), #bevy_reflect_path::ApplyError> {
                 if let #bevy_reflect_path::ReflectRef::Struct(struct_value)
                     = #bevy_reflect_path::PartialReflect::reflect_ref(value) {
-                    for (name, value) in #bevy_reflect_path::structs::Struct::iter_fields(struct_value) {
+                    for (i, value) in ::core::iter::Iterator::enumerate(#bevy_reflect_path::structs::Struct::iter_fields(struct_value)) {
+                        let name = #bevy_reflect_path::structs::Struct::name_at(struct_value, i).unwrap();
                         if let #FQOption::Some(v) = #bevy_reflect_path::structs::Struct::field_mut(self, name) {
                            #bevy_reflect_path::PartialReflect::try_apply(v, value)?;
                         }

crates/bevy_reflect/src/enums/dynamic_enum.rs

@@ -246,7 +246,7 @@ impl Enum for DynamicEnum {
 
     fn index_of(&self, name: &str) -> Option<usize> {
         if let DynamicVariant::Struct(data) = &self.variant {
-            data.index_of_name(name)
+            data.index_of(name)
         } else {
             None
         }

crates/bevy_reflect/src/lib.rs

@@ -1117,7 +1117,7 @@ mod tests {
 
         let values: Vec<u32> = foo
             .iter_fields()
-            .map(|(_, value)| *value.try_downcast_ref::<u32>().unwrap())
+            .map(|value| *value.try_downcast_ref::<u32>().unwrap())
             .collect();
         assert_eq!(values, vec![1]);
     }

crates/bevy_reflect/src/serde/ser/structs.rs

@@ -48,7 +48,7 @@ impl<P: ReflectSerializerProcessor> Serialize for StructSerializer<'_, P> {
             self.struct_value.field_len() - ignored_len,
         )?;
 
-        for (index, (_, value)) in self.struct_value.iter_fields().enumerate() {
+        for (index, value) in self.struct_value.iter_fields().enumerate() {
             if serialization_data.is_some_and(|data| data.is_field_skipped(index)) {
                 continue;
             }