Fix clippy errors

Author: MrGVSV

crates/bevy_reflect/src/enums/enum_trait.rs

@@ -150,10 +150,7 @@ impl EnumInfo {
         let variant_indices = variants
             .iter()
             .enumerate()
-            .map(|(index, variant)| {
-                let name = variant.name().clone();
-                (name, index)
-            })
+            .map(|(index, variant)| (variant.name(), index))
             .collect::<HashMap<_, _>>();
 
         let variant_names = variants

crates/bevy_reflect/src/enums/variants.rs

@@ -137,10 +137,7 @@ impl StructVariantInfo {
         fields
             .iter()
             .enumerate()
-            .map(|(index, field)| {
-                let name = field.name().clone();
-                (name, index)
-            })
+            .map(|(index, field)| (field.name(), index))
             .collect()
     }
 }

crates/bevy_reflect/src/fields.rs

@@ -21,7 +21,7 @@ impl NamedField {
 
     /// The name of the field.
     pub fn name(&self) -> &'static str {
-        &self.name
+        self.name
     }
 
     /// The [type name] of the field.

crates/bevy_reflect/src/serde/de.rs

@@ -579,47 +579,44 @@ impl<'a, 'de> Visitor<'de> for EnumVisitor<'a> {
         A: EnumAccess<'de>,
     {
         let mut dynamic_enum = DynamicEnum::default();
-        match data.variant().unwrap() {
-            (Ident(variant_name), variant) => {
-                let variant_info = self.enum_info.variant(&variant_name).ok_or_else(|| {
-                    Error::unknown_variant(&variant_name, self.enum_info.variant_names())
+        let (Ident(variant_name), variant) = data.variant().unwrap();
+        let variant_info = self
+            .enum_info
+            .variant(&variant_name)
+            .ok_or_else(|| Error::unknown_variant(&variant_name, self.enum_info.variant_names()))?;
+        let value: DynamicVariant = match variant_info {
+            VariantInfo::Unit(..) => variant.unit_variant()?.into(),
+            VariantInfo::Struct(struct_info) => variant
+                .struct_variant(
+                    struct_info.field_names(),
+                    StructVariantVisitor {
+                        struct_info,
+                        registry: self.registry,
+                    },
+                )?
+                .into(),
+            VariantInfo::Tuple(tuple_info) if tuple_info.field_len() == 1 => {
+                let type_info = get_newtype_info(tuple_info, self.registry)?;
+                let value = variant.newtype_variant_seed(TypedReflectDeserializer {
+                    type_info,
+                    registry: self.registry,
                 })?;
-                let value: DynamicVariant = match variant_info {
-                    VariantInfo::Unit(..) => variant.unit_variant()?.into(),
-                    VariantInfo::Struct(struct_info) => variant
-                        .struct_variant(
-                            struct_info.field_names(),
-                            StructVariantVisitor {
-                                struct_info,
-                                registry: self.registry,
-                            },
-                        )?
-                        .into(),
-                    VariantInfo::Tuple(tuple_info) if tuple_info.field_len() == 1 => {
-                        let type_info = get_newtype_info(tuple_info, self.registry)?;
-                        let value = variant.newtype_variant_seed(TypedReflectDeserializer {
-                            type_info,
-                            registry: self.registry,
-                        })?;
-                        let mut dynamic_tuple = DynamicTuple::default();
-                        dynamic_tuple.insert_boxed(value);
-                        dynamic_tuple.into()
-                    }
-                    VariantInfo::Tuple(tuple_info) => variant
-                        .tuple_variant(
-                            tuple_info.field_len(),
-                            TupleVariantVisitor {
-                                tuple_info,
-                                registry: self.registry,
-                            },
-                        )?
-                        .into(),
-                };
-
-                dynamic_enum.set_variant(variant_name, value);
+                let mut dynamic_tuple = DynamicTuple::default();
+                dynamic_tuple.insert_boxed(value);
+                dynamic_tuple.into()
             }
-        }
+            VariantInfo::Tuple(tuple_info) => variant
+                .tuple_variant(
+                    tuple_info.field_len(),
+                    TupleVariantVisitor {
+                        tuple_info,
+                        registry: self.registry,
+                    },
+                )?
+                .into(),
+        };
 
+        dynamic_enum.set_variant(variant_name, value);
         Ok(dynamic_enum)
     }
 }

crates/bevy_reflect/src/serde/ser.rs

@@ -53,12 +53,10 @@ fn get_type_info<E: Error>(
     match type_info {
         TypeInfo::Dynamic(..) => match registry.get_with_name(type_name) {
             Some(registration) => Ok(registration.type_info()),
-            None => {
-                return Err(Error::custom(format_args!(
-                    "no registration found for dynamic type with name {}",
-                    type_name
-                )))
-            }
+            None => Err(Error::custom(format_args!(
+                "no registration found for dynamic type with name {}",
+                type_name
+            ))),
         },
         info => Ok(info),
     }
@@ -207,7 +205,7 @@ impl<'a> Serialize for StructSerializer<'a> {
             serializer.serialize_struct(struct_info.name(), self.struct_value.field_len())?;
         for (index, value) in self.struct_value.iter_fields().enumerate() {
             let key = struct_info.field_at(index).unwrap().name();
-            state.serialize_field(&key, &TypedReflectSerializer::new(value, self.registry))?;
+            state.serialize_field(key, &TypedReflectSerializer::new(value, self.registry))?;
         }
         state.end()
     }

crates/bevy_reflect/src/struct_trait.rs

@@ -89,10 +89,7 @@ impl StructInfo {
         let field_indices = fields
             .iter()
             .enumerate()
-            .map(|(index, field)| {
-                let name = field.name().clone();
-                (name, index)
-            })
+            .map(|(index, field)| (field.name(), index))
             .collect::<HashMap<_, _>>();
         let field_names = fields.iter().map(|field| field.name()).collect::<Vec<_>>();