Pr bevyengine#5723

Author: MrGVSV

assets/scenes/load_scene_example.scn.ron

@@ -3,61 +3,41 @@
     entity: 0,
     components: [
       {
-        "type": "bevy_transform::components::transform::Transform",
-        "struct": {
-          "translation": {
-            "type": "glam::vec3::Vec3",
-            "value": (0.0, 0.0, 0.0),
-          },
-          "rotation": {
-            "type": "glam::quat::Quat",
-            "value": (0.0, 0.0, 0.0, 1.0),
-          },
-          "scale": {
-            "type": "glam::vec3::Vec3",
-            "value": (1.0, 1.0, 1.0),
-          },
-        },
+        "bevy_transform::components::transform::Transform": (
+          translation: (
+            x: 0.0,
+            y: 0.0,
+            z: 0.0
+          ),
+          rotation: (0.0, 0.0, 0.0, 1.0),
+          scale: (
+            x: 1.0,
+            y: 1.0,
+            z: 1.0
+          ),
+        ),
       },
       {
-        "type": "scene::ComponentB",
-        "struct": {
-          "value": {
-            "type": "alloc::string::String",
-            "value": "hello",
-          },
-        },
+        "scene::ComponentB": (
+          value: "hello",
+        ),
       },
       {
-        "type": "scene::ComponentA",
-        "struct": {
-          "x": {
-            "type": "f32",
-            "value": 1.0,
-          },
-          "y": {
-            "type": "f32",
-            "value": 2.0,
-          },
-        },
+        "scene::ComponentA": (
+          x: 1.0,
+          y: 2.0,
+        ),
       },
     ],
   ),
   (
     entity: 1,
     components: [
       {
-        "type": "scene::ComponentA",
-        "struct": {
-          "x": {
-            "type": "f32",
-            "value": 3.0,
-          },
-          "y": {
-            "type": "f32",
-            "value": 4.0,
-          },
-        },
+        "scene::ComponentA": (
+          x: 3.0,
+          y: 4.0,
+        ),
       },
     ],
   ),

crates/bevy_reflect/bevy_reflect_derive/src/impls/enums.rs

@@ -53,12 +53,13 @@ pub(crate) fn impl_enum(reflect_enum: &ReflectEnum) -> TokenStream {
             }
         });
 
+    let string_name = enum_name.to_string();
     let typed_impl = impl_typed(
         enum_name,
         reflect_enum.meta().generics(),
         quote! {
             let variants = [#(#variant_info),*];
-            let info = #bevy_reflect_path::EnumInfo::new::<Self>(&variants);
+            let info = #bevy_reflect_path::EnumInfo::new::<Self>(#string_name, &variants);
             #bevy_reflect_path::TypeInfo::Enum(info)
         },
         bevy_reflect_path,

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

@@ -51,14 +51,15 @@ pub(crate) fn impl_struct(reflect_struct: &ReflectStruct) -> TokenStream {
             }
         });
 
+    let string_name = struct_name.to_string();
     let typed_impl = impl_typed(
         struct_name,
         reflect_struct.meta().generics(),
         quote! {
            let fields = [
                 #(#bevy_reflect_path::NamedField::new::<#field_types, _>(#field_names),)*
             ];
-            let info = #bevy_reflect_path::StructInfo::new::<Self>(&fields);
+            let info = #bevy_reflect_path::StructInfo::new::<Self>(#string_name, &fields);
             #bevy_reflect_path::TypeInfo::Struct(info)
         },
         bevy_reflect_path,

crates/bevy_reflect/bevy_reflect_derive/src/impls/tuple_structs.rs

@@ -35,14 +35,15 @@ pub(crate) fn impl_tuple_struct(reflect_struct: &ReflectStruct) -> TokenStream {
             }
         });
 
+    let string_name = struct_name.to_string();
     let typed_impl = impl_typed(
         struct_name,
         reflect_struct.meta().generics(),
         quote! {
             let fields = [
                 #(#bevy_reflect_path::UnnamedField::new::<#field_types>(#field_idents),)*
             ];
-            let info = #bevy_reflect_path::TupleStructInfo::new::<Self>(&fields);
+            let info = #bevy_reflect_path::TupleStructInfo::new::<Self>(#string_name, &fields);
             #bevy_reflect_path::TypeInfo::TupleStruct(info)
         },
         bevy_reflect_path,

crates/bevy_reflect/src/enums/enum_trait.rs

@@ -1,7 +1,6 @@
 use crate::{DynamicEnum, Reflect, VariantInfo, VariantType};
 use bevy_utils::HashMap;
 use std::any::{Any, TypeId};
-use std::borrow::Cow;
 use std::slice::Iter;
 
 /// A trait representing a [reflected] enum.
@@ -131,33 +130,40 @@ pub trait Enum: Reflect {
 /// A container for compile-time enum info, used by [`TypeInfo`](crate::TypeInfo).
 #[derive(Clone, Debug)]
 pub struct EnumInfo {
+    name: &'static str,
     type_name: &'static str,
     type_id: TypeId,
     variants: Box<[VariantInfo]>,
-    variant_indices: HashMap<Cow<'static, str>, usize>,
+    variant_names: Box<[&'static str]>,
+    variant_indices: HashMap<&'static str, usize>,
 }
 
 impl EnumInfo {
     /// Create a new [`EnumInfo`].
     ///
     /// # Arguments
     ///
+    /// * `name`: The name of this enum (_without_ generics or lifetimes)
     /// * `variants`: The variants of this enum in the order they are defined
     ///
-    pub fn new<TEnum: Enum>(variants: &[VariantInfo]) -> Self {
+    pub fn new<TEnum: Enum>(name: &'static str, variants: &[VariantInfo]) -> Self {
         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
+            .iter()
+            .map(|variant| variant.name())
+            .collect::<Vec<_>>();
+
         Self {
+            name,
             type_name: std::any::type_name::<TEnum>(),
             type_id: TypeId::of::<TEnum>(),
             variants: variants.to_vec().into_boxed_slice(),
+            variant_names: variant_names.into_boxed_slice(),
             variant_indices,
         }
     }
@@ -169,6 +175,11 @@ impl EnumInfo {
             .map(|index| &self.variants[*index])
     }
 
+    /// A slice containing the names of all variants in order.
+    pub fn variant_names(&self) -> &[&'static str] {
+        &self.variant_names
+    }
+
     /// Get a variant at the given index.
     pub fn variant_at(&self, index: usize) -> Option<&VariantInfo> {
         self.variants.get(index)
@@ -201,6 +212,15 @@ impl EnumInfo {
         self.variants.len()
     }
 
+    /// The name of the enum.
+    ///
+    /// This does _not_ include any generics or lifetimes.
+    ///
+    /// For example, `foo::bar::Baz<'a, T>` would simply be `Baz`.
+    pub fn name(&self) -> &'static str {
+        self.name
+    }
+
     /// The [type name] of the enum.
     ///
     /// [type name]: std::any::type_name

crates/bevy_reflect/src/enums/variants.rs

@@ -1,6 +1,5 @@
 use crate::{NamedField, UnnamedField};
 use bevy_utils::HashMap;
-use std::borrow::Cow;
 use std::slice::Iter;
 
 /// Describes the form of an enum variant.
@@ -66,7 +65,7 @@ pub enum VariantInfo {
 }
 
 impl VariantInfo {
-    pub fn name(&self) -> &Cow<'static, str> {
+    pub fn name(&self) -> &'static str {
         match self {
             Self::Struct(info) => info.name(),
             Self::Tuple(info) => info.name(),
@@ -78,39 +77,28 @@ impl VariantInfo {
 /// Type info for struct variants.
 #[derive(Clone, Debug)]
 pub struct StructVariantInfo {
-    name: Cow<'static, str>,
+    name: &'static str,
     fields: Box<[NamedField]>,
-    field_indices: HashMap<Cow<'static, str>, usize>,
+    field_names: Box<[&'static str]>,
+    field_indices: HashMap<&'static str, usize>,
 }
 
 impl StructVariantInfo {
     /// Create a new [`StructVariantInfo`].
-    pub fn new(name: &str, fields: &[NamedField]) -> Self {
-        let field_indices = Self::collect_field_indices(fields);
-
-        Self {
-            name: Cow::Owned(name.into()),
-            fields: fields.to_vec().into_boxed_slice(),
-            field_indices,
-        }
-    }
-
-    /// Create a new [`StructVariantInfo`] using a static string.
-    ///
-    /// This helps save an allocation when the string has a static lifetime, such
-    /// as when using defined sa a literal.
-    pub fn new_static(name: &'static str, fields: &[NamedField]) -> Self {
+    pub fn new(name: &'static str, fields: &[NamedField]) -> Self {
         let field_indices = Self::collect_field_indices(fields);
+        let field_names = fields.iter().map(|field| field.name()).collect::<Vec<_>>();
         Self {
-            name: Cow::Borrowed(name),
+            name,
             fields: fields.to_vec().into_boxed_slice(),
+            field_names: field_names.into_boxed_slice(),
             field_indices,
         }
     }
 
     /// The name of this variant.
-    pub fn name(&self) -> &Cow<'static, str> {
-        &self.name
+    pub fn name(&self) -> &'static str {
+        self.name
     }
 
     /// Get the field with the given name.
@@ -120,6 +108,11 @@ impl StructVariantInfo {
             .map(|index| &self.fields[*index])
     }
 
+    /// A slice containing the names of all fields in order.
+    pub fn field_names(&self) -> &[&'static str] {
+        &self.field_names
+    }
+
     /// Get the field at the given index.
     pub fn field_at(&self, index: usize) -> Option<&NamedField> {
         self.fields.get(index)
@@ -140,48 +133,34 @@ impl StructVariantInfo {
         self.fields.len()
     }
 
-    fn collect_field_indices(fields: &[NamedField]) -> HashMap<Cow<'static, str>, usize> {
+    fn collect_field_indices(fields: &[NamedField]) -> HashMap<&'static str, usize> {
         fields
             .iter()
             .enumerate()
-            .map(|(index, field)| {
-                let name = field.name().clone();
-                (name, index)
-            })
+            .map(|(index, field)| (field.name(), index))
             .collect()
     }
 }
 
 /// Type info for tuple variants.
 #[derive(Clone, Debug)]
 pub struct TupleVariantInfo {
-    name: Cow<'static, str>,
+    name: &'static str,
     fields: Box<[UnnamedField]>,
 }
 
 impl TupleVariantInfo {
     /// Create a new [`TupleVariantInfo`].
-    pub fn new(name: &str, fields: &[UnnamedField]) -> Self {
-        Self {
-            name: Cow::Owned(name.into()),
-            fields: fields.to_vec().into_boxed_slice(),
-        }
-    }
-
-    /// Create a new [`TupleVariantInfo`] using a static string.
-    ///
-    /// This helps save an allocation when the string has a static lifetime, such
-    /// as when using defined sa a literal.
-    pub fn new_static(name: &'static str, fields: &[UnnamedField]) -> Self {
+    pub fn new(name: &'static str, fields: &[UnnamedField]) -> Self {
         Self {
-            name: Cow::Borrowed(name),
+            name,
             fields: fields.to_vec().into_boxed_slice(),
         }
     }
 
     /// The name of this variant.
-    pub fn name(&self) -> &Cow<'static, str> {
-        &self.name
+    pub fn name(&self) -> &'static str {
+        self.name
     }
 
     /// Get the field at the given index.
@@ -203,29 +182,17 @@ impl TupleVariantInfo {
 /// Type info for unit variants.
 #[derive(Clone, Debug)]
 pub struct UnitVariantInfo {
-    name: Cow<'static, str>,
+    name: &'static str,
 }
 
 impl UnitVariantInfo {
     /// Create a new [`UnitVariantInfo`].
-    pub fn new(name: &str) -> Self {
-        Self {
-            name: Cow::Owned(name.into()),
-        }
-    }
-
-    /// Create a new [`UnitVariantInfo`] using a static string.
-    ///
-    /// This helps save an allocation when the string has a static lifetime, such
-    /// as when using defined sa a literal.
-    pub fn new_static(name: &'static str) -> Self {
-        Self {
-            name: Cow::Borrowed(name),
-        }
+    pub fn new(name: &'static str) -> Self {
+        Self { name }
     }
 
     /// The name of this variant.
-    pub fn name(&self) -> &Cow<'static, str> {
-        &self.name
+    pub fn name(&self) -> &'static str {
+        self.name
     }
 }