Implement MrGVSV suggestions (round 1)

Co-authored-by: Gino Valente <[email protected]>

Author: nicopap

crates/bevy_reflect/src/lib.rs

@@ -233,7 +233,7 @@
 //!
 //! The [`GetPath`] trait allows accessing arbitrary nested fields of a [`Reflect`] type.
 //!
-//! Using [`GetPath`], it is possible to use a path strings to access a specific field
+//! Using `GetPath`, it is possible to use a path string to access a specific field
 //! of a reflected type.
 //!
 //! ```
@@ -252,8 +252,6 @@
 //! );
 //! ```
 //!
-//! Check the [`GetPath`] documentation for more details.
-//!
 //! # Type Registration
 //!
 //! This crate also comes with a [`TypeRegistry`] that can be used to store and retrieve additional type metadata at runtime,

crates/bevy_reflect/src/path/access.rs

@@ -1,6 +1,6 @@
 use std::fmt;
 
-use super::ReflectPathError;
+use super::{AccessError, ReflectPathError};
 use crate::{Reflect, ReflectMut, ReflectRef, VariantType};
 use thiserror::Error;
 
@@ -13,34 +13,43 @@ pub(super) enum Error<'a> {
         access.kind(),
         access.display_value(),
     )]
-    Access { ty: Type, access: AccessRef<'a> },
+    Access {
+        ty: TypeShape,
+        access: AccessRef<'a>,
+    },
 
     #[error("invalid type shape: expected {expected} but found a reflect {actual}")]
-    Type { expected: Type, actual: Type },
+    Type {
+        expected: TypeShape,
+        actual: TypeShape,
+    },
 
     #[error("invalid enum access: expected {expected} variant but found {actual} variant")]
-    Enum { expected: Type, actual: Type },
+    Enum {
+        expected: TypeShape,
+        actual: TypeShape,
+    },
 }
 
 impl<'a> Error<'a> {
     fn with_offset(self, offset: usize) -> ReflectPathError<'a> {
-        let error = super::AccessError(self);
+        let error = AccessError(self);
         ReflectPathError::InvalidAccess { offset, error }
     }
 }
 impl Error<'static> {
-    fn bad_enum(expected: Type, actual: impl Into<Type>) -> Self {
+    fn bad_enum_variant(expected: TypeShape, actual: impl Into<TypeShape>) -> Self {
         let actual = actual.into();
         Error::Enum { expected, actual }
     }
-    fn bad_type(expected: Type, actual: impl Into<Type>) -> Self {
+    fn bad_type(expected: TypeShape, actual: impl Into<TypeShape>) -> Self {
         let actual = actual.into();
         Error::Type { expected, actual }
     }
 }
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub(super) enum Type {
+pub(super) enum TypeShape {
     Struct,
     TupleStruct,
     Tuple,
@@ -52,42 +61,42 @@ pub(super) enum Type {
     Unit,
 }
 
-impl fmt::Display for Type {
+impl fmt::Display for TypeShape {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let name = match self {
-            Type::Struct => "struct",
-            Type::TupleStruct => "tuple struct",
-            Type::Tuple => "tuple",
-            Type::List => "list",
-            Type::Array => "array",
-            Type::Map => "map",
-            Type::Enum => "enum",
-            Type::Value => "value",
-            Type::Unit => "unit",
+            TypeShape::Struct => "struct",
+            TypeShape::TupleStruct => "tuple struct",
+            TypeShape::Tuple => "tuple",
+            TypeShape::List => "list",
+            TypeShape::Array => "array",
+            TypeShape::Map => "map",
+            TypeShape::Enum => "enum",
+            TypeShape::Value => "value",
+            TypeShape::Unit => "unit",
         };
         write!(f, "{name}")
     }
 }
-impl<'a> From<ReflectRef<'a>> for Type {
+impl<'a> From<ReflectRef<'a>> for TypeShape {
     fn from(value: ReflectRef<'a>) -> Self {
         match value {
-            ReflectRef::Struct(_) => Type::Struct,
-            ReflectRef::TupleStruct(_) => Type::TupleStruct,
-            ReflectRef::Tuple(_) => Type::Tuple,
-            ReflectRef::List(_) => Type::List,
-            ReflectRef::Array(_) => Type::Array,
-            ReflectRef::Map(_) => Type::Map,
-            ReflectRef::Enum(_) => Type::Enum,
-            ReflectRef::Value(_) => Type::Value,
+            ReflectRef::Struct(_) => TypeShape::Struct,
+            ReflectRef::TupleStruct(_) => TypeShape::TupleStruct,
+            ReflectRef::Tuple(_) => TypeShape::Tuple,
+            ReflectRef::List(_) => TypeShape::List,
+            ReflectRef::Array(_) => TypeShape::Array,
+            ReflectRef::Map(_) => TypeShape::Map,
+            ReflectRef::Enum(_) => TypeShape::Enum,
+            ReflectRef::Value(_) => TypeShape::Value,
         }
     }
 }
-impl From<VariantType> for Type {
+impl From<VariantType> for TypeShape {
     fn from(value: VariantType) -> Self {
         match value {
-            VariantType::Struct => Type::Struct,
-            VariantType::Tuple => Type::Tuple,
-            VariantType::Unit => Type::Unit,
+            VariantType::Struct => TypeShape::Struct,
+            VariantType::Tuple => TypeShape::Tuple,
+            VariantType::Unit => TypeShape::Unit,
         }
     }
 }
@@ -116,6 +125,17 @@ impl fmt::Display for Access {
     }
 }
 
+impl Access {
+    pub(super) fn as_ref(&self) -> AccessRef<'_> {
+        match self {
+            Self::Field(value) => AccessRef::Field(value),
+            Self::FieldIndex(value) => AccessRef::FieldIndex(*value),
+            Self::TupleIndex(value) => AccessRef::TupleIndex(*value),
+            Self::ListIndex(value) => AccessRef::ListIndex(*value),
+        }
+    }
+}
+
 /// A singular borrowed element access within a path.
 ///
 /// Can be applied to a `dyn Reflect` to get a reference to the targeted element.
@@ -130,17 +150,6 @@ pub(super) enum AccessRef<'a> {
     ListIndex(usize),
 }
 
-impl Access {
-    pub(super) fn as_ref(&self) -> AccessRef<'_> {
-        match self {
-            Self::Field(value) => AccessRef::Field(value),
-            Self::FieldIndex(value) => AccessRef::FieldIndex(*value),
-            Self::TupleIndex(value) => AccessRef::TupleIndex(*value),
-            Self::ListIndex(value) => AccessRef::ListIndex(*value),
-        }
-    }
-}
-
 impl<'a> AccessRef<'a> {
     pub(super) fn to_owned(self) -> Access {
         match self {
@@ -175,29 +184,30 @@ impl<'a> AccessRef<'a> {
             .and_then(|maybe| maybe.ok_or(Error::Access { ty, access: self }))
             .map_err(|err| err.with_offset(offset))
     }
+
     fn element_inner(self, base: &dyn Reflect) -> InnerResult<&dyn Reflect> {
         use ReflectRef::*;
         match (self, base.reflect_ref()) {
             (Self::Field(field), Struct(struct_ref)) => Ok(struct_ref.field(field)),
             (Self::Field(field), Enum(enum_ref)) => match enum_ref.variant_type() {
                 VariantType::Struct => Ok(enum_ref.field(field)),
-                actual => Err(Error::bad_enum(Type::Struct, actual)),
+                actual => Err(Error::bad_enum_variant(TypeShape::Struct, actual)),
             },
             (Self::FieldIndex(index), Struct(struct_ref)) => Ok(struct_ref.field_at(index)),
             (Self::FieldIndex(index), Enum(enum_ref)) => match enum_ref.variant_type() {
                 VariantType::Struct => Ok(enum_ref.field_at(index)),
-                actual => Err(Error::bad_enum(Type::Struct, actual)),
+                actual => Err(Error::bad_enum_variant(TypeShape::Struct, actual)),
             },
             (Self::TupleIndex(index), TupleStruct(tuple)) => Ok(tuple.field(index)),
             (Self::TupleIndex(index), Tuple(tuple)) => Ok(tuple.field(index)),
             (Self::TupleIndex(index), Enum(enum_ref)) => match enum_ref.variant_type() {
                 VariantType::Tuple => Ok(enum_ref.field_at(index)),
-                actual => Err(Error::bad_enum(Type::Tuple, actual)),
+                actual => Err(Error::bad_enum_variant(TypeShape::Tuple, actual)),
             },
             (Self::ListIndex(index), List(list)) => Ok(list.get(index)),
             (Self::ListIndex(index), Array(list)) => Ok(list.get(index)),
-            (Self::ListIndex(_), actual) => Err(Error::bad_type(Type::List, actual)),
-            (_, actual) => Err(Error::bad_type(Type::Struct, actual)),
+            (Self::ListIndex(_), actual) => Err(Error::bad_type(TypeShape::List, actual)),
+            (_, actual) => Err(Error::bad_type(TypeShape::Struct, actual)),
         }
     }
 
@@ -211,30 +221,31 @@ impl<'a> AccessRef<'a> {
             .and_then(|maybe| maybe.ok_or(Error::Access { ty, access: self }))
             .map_err(|err| err.with_offset(offset))
     }
+
     fn element_inner_mut(self, base: &mut dyn Reflect) -> InnerResult<&mut dyn Reflect> {
         use ReflectMut::*;
-        let base_kind: Type = base.reflect_ref().into();
+        let base_kind: TypeShape = base.reflect_ref().into();
         match (self, base.reflect_mut()) {
             (Self::Field(field), Struct(struct_mut)) => Ok(struct_mut.field_mut(field)),
             (Self::Field(field), Enum(enum_mut)) => match enum_mut.variant_type() {
                 VariantType::Struct => Ok(enum_mut.field_mut(field)),
-                actual => Err(Error::bad_enum(Type::Struct, actual)),
+                actual => Err(Error::bad_enum_variant(TypeShape::Struct, actual)),
             },
             (Self::FieldIndex(index), Struct(struct_mut)) => Ok(struct_mut.field_at_mut(index)),
             (Self::FieldIndex(index), Enum(enum_mut)) => match enum_mut.variant_type() {
                 VariantType::Struct => Ok(enum_mut.field_at_mut(index)),
-                actual => Err(Error::bad_enum(Type::Struct, actual)),
+                actual => Err(Error::bad_enum_variant(TypeShape::Struct, actual)),
             },
             (Self::TupleIndex(index), TupleStruct(tuple)) => Ok(tuple.field_mut(index)),
             (Self::TupleIndex(index), Tuple(tuple)) => Ok(tuple.field_mut(index)),
             (Self::TupleIndex(index), Enum(enum_mut)) => match enum_mut.variant_type() {
                 VariantType::Tuple => Ok(enum_mut.field_at_mut(index)),
-                actual => Err(Error::bad_enum(Type::Tuple, actual)),
+                actual => Err(Error::bad_enum_variant(TypeShape::Tuple, actual)),
             },
             (Self::ListIndex(index), List(list)) => Ok(list.get_mut(index)),
             (Self::ListIndex(index), Array(list)) => Ok(list.get_mut(index)),
-            (Self::ListIndex(_), _) => Err(Error::bad_type(Type::List, base_kind)),
-            (_, _) => Err(Error::bad_type(Type::Struct, base_kind)),
+            (Self::ListIndex(_), _) => Err(Error::bad_type(TypeShape::List, base_kind)),
+            (_, _) => Err(Error::bad_type(TypeShape::Struct, base_kind)),
         }
     }
 }

crates/bevy_reflect/src/path/mod.rs

@@ -14,7 +14,7 @@ type ParseResult<T> = Result<T, ReflectPathParseError>;
 #[error(transparent)]
 pub struct AccessError<'a>(access::Error<'a>);
 
-/// A parse error for a path string query.
+/// A parse error for a path string.
 #[derive(Debug, PartialEq, Eq, Error)]
 pub enum ReflectPathParseError {
     #[error("expected an identifier at offset {offset}")]
@@ -558,7 +558,7 @@ mod tests {
     use super::*;
     use crate as bevy_reflect;
     use crate::*;
-    use access::Type;
+    use access::TypeShape;
 
     #[derive(Reflect)]
     struct A {
@@ -777,7 +777,7 @@ mod tests {
             ReflectPathError::InvalidAccess {
                 offset: 2,
                 error: AccessError(access::Error::Access {
-                    ty: Type::Struct,
+                    ty: TypeShape::Struct,
                     access: AccessRef::Field("notreal"),
                 }),
             }
@@ -788,8 +788,8 @@ mod tests {
             ReflectPathError::InvalidAccess {
                 offset: 13,
                 error: AccessError(access::Error::Enum {
-                    actual: Type::Unit,
-                    expected: Type::Tuple
+                    actual: TypeShape::Unit,
+                    expected: TypeShape::Tuple
                 }),
             }
         );
@@ -804,8 +804,8 @@ mod tests {
             ReflectPathError::InvalidAccess {
                 offset: 2,
                 error: AccessError(access::Error::Type {
-                    actual: Type::Struct,
-                    expected: Type::List
+                    actual: TypeShape::Struct,
+                    expected: TypeShape::List
                 }),
             }
         );
@@ -815,8 +815,8 @@ mod tests {
             ReflectPathError::InvalidAccess {
                 offset: 2,
                 error: AccessError(access::Error::Type {
-                    actual: Type::List,
-                    expected: Type::Struct
+                    actual: TypeShape::List,
+                    expected: TypeShape::Struct
                 }),
             }
         );