Remove thiserror from bevy_reflect (#15766)

# Objective

- Contributes to #15460

## Solution

- Removed `thiserror` from `bevy_reflect`

crates/bevy_reflect/Cargo.toml

@@ -38,7 +38,11 @@ bevy_ptr = { path = "../bevy_ptr", version = "0.15.0-dev" }
 erased-serde = "0.4"
 disqualified = "1.0"
 downcast-rs = "1.2"
-thiserror = "1.0"
+derive_more = { version = "1", default-features = false, features = [
+  "error",
+  "from",
+  "display",
+] }
 serde = "1"
 smallvec = { version = "1.11", optional = true }
 assert_type_match = "0.1.1"

crates/bevy_reflect/src/enums/dynamic_enum.rs

@@ -7,9 +7,10 @@ use crate::{
 };
 
 use core::fmt::Formatter;
+use derive_more::derive::From;
 
 /// A dynamic representation of an enum variant.
-#[derive(Debug, Default)]
+#[derive(Debug, Default, From)]
 pub enum DynamicVariant {
     #[default]
     Unit,
@@ -27,18 +28,6 @@ impl Clone for DynamicVariant {
     }
 }
 
-impl From<DynamicTuple> for DynamicVariant {
-    fn from(dyn_tuple: DynamicTuple) -> Self {
-        Self::Tuple(dyn_tuple)
-    }
-}
-
-impl From<DynamicStruct> for DynamicVariant {
-    fn from(dyn_struct: DynamicStruct) -> Self {
-        Self::Struct(dyn_struct)
-    }
-}
-
 impl From<()> for DynamicVariant {
     fn from(_: ()) -> Self {
         Self::Unit

crates/bevy_reflect/src/enums/variants.rs

@@ -6,7 +6,7 @@ use bevy_utils::HashMap;
 use core::slice::Iter;
 
 use alloc::sync::Arc;
-use thiserror::Error;
+use derive_more::derive::{Display, Error};
 
 /// Describes the form of an enum variant.
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
@@ -40,12 +40,12 @@ pub enum VariantType {
 }
 
 /// A [`VariantInfo`]-specific error.
-#[derive(Debug, Error)]
+#[derive(Debug, Error, Display)]
 pub enum VariantInfoError {
     /// Caused when a variant was expected to be of a certain [type], but was not.
     ///
     /// [type]: VariantType
-    #[error("variant type mismatch: expected {expected:?}, received {received:?}")]
+    #[display("variant type mismatch: expected {expected:?}, received {received:?}")]
     TypeMismatch {
         expected: VariantType,
         received: VariantType,

crates/bevy_reflect/src/func/args/error.rs

@@ -1,23 +1,25 @@
 use alloc::borrow::Cow;
 
-use thiserror::Error;
+use derive_more::derive::{Display, Error};
 
 use crate::func::args::Ownership;
 
 /// An error that occurs when converting an [argument].
 ///
 /// [argument]: crate::func::args::Arg
-#[derive(Debug, Error, PartialEq)]
+#[derive(Debug, Error, Display, PartialEq)]
 pub enum ArgError {
     /// The argument is not the expected type.
-    #[error("expected `{expected}` but received `{received}` (@ argument index {index})")]
+    #[display("expected `{expected}` but received `{received}` (@ argument index {index})")]
     UnexpectedType {
         index: usize,
         expected: Cow<'static, str>,
         received: Cow<'static, str>,
     },
     /// The argument has the wrong ownership.
-    #[error("expected {expected} value but received {received} value (@ argument index {index})")]
+    #[display(
+        "expected {expected} value but received {received} value (@ argument index {index})"
+    )]
     InvalidOwnership {
         index: usize,
         expected: Ownership,
@@ -26,6 +28,6 @@ pub enum ArgError {
     /// Occurs when attempting to access an argument from an empty [`ArgList`].
     ///
     /// [`ArgList`]: crate::func::args::ArgList
-    #[error("expected an argument but received none")]
+    #[display("expected an argument but received none")]
     EmptyArgList,
 }

crates/bevy_reflect/src/func/error.rs

@@ -1,18 +1,17 @@
 use crate::func::{args::ArgError, Return};
 use alloc::borrow::Cow;
-use thiserror::Error;
+use derive_more::derive::{Display, Error, From};
 
 /// An error that occurs when calling a [`DynamicFunction`] or [`DynamicFunctionMut`].
 ///
 /// [`DynamicFunction`]: crate::func::DynamicFunction
 /// [`DynamicFunctionMut`]: crate::func::DynamicFunctionMut
-#[derive(Debug, Error, PartialEq)]
+#[derive(Debug, Error, Display, PartialEq, From)]
 pub enum FunctionError {
     /// An error occurred while converting an argument.
-    #[error(transparent)]
-    ArgError(#[from] ArgError),
+    ArgError(ArgError),
     /// The number of arguments provided does not match the expected number.
-    #[error("expected {expected} arguments but received {received}")]
+    #[display("expected {expected} arguments but received {received}")]
     ArgCountMismatch { expected: usize, received: usize },
 }
 
@@ -28,14 +27,15 @@ pub type FunctionResult<'a> = Result<Return<'a>, FunctionError>;
 /// An error that occurs when registering a function into a [`FunctionRegistry`].
 ///
 /// [`FunctionRegistry`]: crate::func::FunctionRegistry
-#[derive(Debug, Error, PartialEq)]
+#[derive(Debug, Error, Display, PartialEq)]
 pub enum FunctionRegistrationError {
     /// A function with the given name has already been registered.
     ///
     /// Contains the duplicate function name.
-    #[error("a function has already been registered with name {0:?}")]
+    #[display("a function has already been registered with name {_0:?}")]
+    #[error(ignore)]
     DuplicateName(Cow<'static, str>),
     /// The function is missing a name by which it can be registered.
-    #[error("function name is missing")]
+    #[display("function name is missing")]
     MissingName,
 }

crates/bevy_reflect/src/generics.rs

@@ -3,6 +3,7 @@ use crate::{Reflect, Type, TypePath};
 use alloc::borrow::Cow;
 use alloc::sync::Arc;
 use core::ops::Deref;
+use derive_more::derive::From;
 
 /// The generic parameters of a type.
 ///
@@ -63,7 +64,7 @@ impl Deref for Generics {
 }
 
 /// An enum representing a generic parameter.
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, From)]
 pub enum GenericInfo {
     /// A type parameter.
     ///
@@ -100,18 +101,6 @@ impl GenericInfo {
     });
 }
 
-impl From<TypeParamInfo> for GenericInfo {
-    fn from(info: TypeParamInfo) -> Self {
-        Self::Type(info)
-    }
-}
-
-impl From<ConstParamInfo> for GenericInfo {
-    fn from(info: ConstParamInfo) -> Self {
-        Self::Const(info)
-    }
-}
-
 /// Type information for a generic type parameter.
 ///
 /// An example of a type parameter would be `T` in `struct Foo<T>`.

crates/bevy_reflect/src/kind.rs

@@ -1,4 +1,4 @@
-use thiserror::Error;
+use derive_more::derive::{Display, Error};
 
 #[cfg(feature = "functions")]
 use crate::func::Function;
@@ -130,8 +130,8 @@ macro_rules! impl_reflect_kind_conversions {
 /// Caused when a type was expected to be of a certain [kind], but was not.
 ///
 /// [kind]: ReflectKind
-#[derive(Debug, Error)]
-#[error("kind mismatch: expected {expected:?}, received {received:?}")]
+#[derive(Debug, Error, Display)]
+#[display("kind mismatch: expected {expected:?}, received {received:?}")]
 pub struct ReflectKindMismatchError {
     pub expected: ReflectKind,
     pub received: ReflectKind,

crates/bevy_reflect/src/path/mod.rs

@@ -10,24 +10,23 @@ use parse::PathParser;
 
 use crate::{PartialReflect, Reflect};
 use core::fmt;
-use thiserror::Error;
+use derive_more::derive::{Display, From};
 
 type PathResult<'a, T> = Result<T, ReflectPathError<'a>>;
 
 /// An error returned from a failed path string query.
-#[derive(Debug, PartialEq, Eq, Error)]
+#[derive(Debug, PartialEq, Eq, Display, From)]
 pub enum ReflectPathError<'a> {
     /// An error caused by trying to access a path that's not able to be accessed,
     /// see [`AccessError`] for details.
-    #[error(transparent)]
     InvalidAccess(AccessError<'a>),
 
     /// An error that occurs when a type cannot downcast to a given type.
-    #[error("Can't downcast result of access to the given type")]
+    #[display("Can't downcast result of access to the given type")]
     InvalidDowncast,
 
     /// An error caused by an invalid path string that couldn't be parsed.
-    #[error("Encountered an error at offset {offset} while parsing `{path}`: {error}")]
+    #[display("Encountered an error at offset {offset} while parsing `{path}`: {error}")]
     ParseError {
         /// Position in `path`.
         offset: usize,
@@ -37,11 +36,8 @@ pub enum ReflectPathError<'a> {
         error: ParseError<'a>,
     },
 }
-impl<'a> From<AccessError<'a>> for ReflectPathError<'a> {
-    fn from(value: AccessError<'a>) -> Self {
-        Self::InvalidAccess(value)
-    }
-}
+
+impl<'a> core::error::Error for ReflectPathError<'a> {}
 
 /// Something that can be interpreted as a reflection path in [`GetPath`].
 pub trait ReflectPath<'a>: Sized {
@@ -355,7 +351,7 @@ impl From<Access<'static>> for OffsetAccess {
 /// ];
 /// let my_path = ParsedPath::from(path_elements);
 /// ```
-#[derive(Clone, Debug, PartialEq, PartialOrd, Ord, Eq, Hash)]
+#[derive(Clone, Debug, PartialEq, PartialOrd, Ord, Eq, Hash, From)]
 pub struct ParsedPath(
     /// This is a vector of pre-parsed [`OffsetAccess`]es.
     pub Vec<OffsetAccess>,
@@ -447,11 +443,6 @@ impl<'a> ReflectPath<'a> for &'a ParsedPath {
         Ok(root)
     }
 }
-impl From<Vec<OffsetAccess>> for ParsedPath {
-    fn from(value: Vec<OffsetAccess>) -> Self {
-        ParsedPath(value)
-    }
-}
 impl<const N: usize> From<[OffsetAccess; N]> for ParsedPath {
     fn from(value: [OffsetAccess; N]) -> Self {
         ParsedPath(value.to_vec())

crates/bevy_reflect/src/path/parse.rs

@@ -4,34 +4,38 @@ use core::{
     str::from_utf8_unchecked,
 };
 
-use thiserror::Error;
+use derive_more::derive::{Display, Error, From};
 
 use super::{Access, ReflectPathError};
 
 /// An error that occurs when parsing reflect path strings.
-#[derive(Debug, PartialEq, Eq, Error)]
-#[error(transparent)]
+#[derive(Debug, PartialEq, Eq, Error, Display)]
+#[error(ignore)]
 pub struct ParseError<'a>(Error<'a>);
 
 /// A parse error for a path string.
-#[derive(Debug, PartialEq, Eq, Error)]
+#[derive(Debug, PartialEq, Eq, Error, Display, From)]
 enum Error<'a> {
-    #[error("expected an identifier, but reached end of path string")]
+    #[display("expected an identifier, but reached end of path string")]
     NoIdent,
 
-    #[error("expected an identifier, got '{0}' instead")]
+    #[display("expected an identifier, got '{_0}' instead")]
+    #[error(ignore)]
+    #[from(ignore)]
     ExpectedIdent(Token<'a>),
 
-    #[error("failed to parse index as integer")]
-    InvalidIndex(#[from] ParseIntError),
+    #[display("failed to parse index as integer")]
+    InvalidIndex(ParseIntError),
 
-    #[error("a '[' wasn't closed, reached end of path string before finding a ']'")]
+    #[display("a '[' wasn't closed, reached end of path string before finding a ']'")]
     Unclosed,
 
-    #[error("a '[' wasn't closed properly, got '{0}' instead")]
+    #[display("a '[' wasn't closed properly, got '{_0}' instead")]
+    #[error(ignore)]
+    #[from(ignore)]
     BadClose(Token<'a>),
 
-    #[error("a ']' was found before an opening '['")]
+    #[display("a ']' was found before an opening '['")]
     CloseBeforeOpen,
 }
 

crates/bevy_reflect/src/reflect.rs

@@ -8,39 +8,39 @@ use core::{
     fmt::Debug,
 };
 
-use thiserror::Error;
+use derive_more::derive::{Display, Error};
 
 use crate::utility::NonGenericTypeInfoCell;
 
 /// A enumeration of all error outcomes that might happen when running [`try_apply`](PartialReflect::try_apply).
-#[derive(Error, Debug)]
+#[derive(Error, Display, Debug)]
 pub enum ApplyError {
-    #[error("attempted to apply `{from_kind}` to `{to_kind}`")]
+    #[display("attempted to apply `{from_kind}` to `{to_kind}`")]
     /// Attempted to apply the wrong [kind](ReflectKind) to a type, e.g. a struct to a enum.
     MismatchedKinds {
         from_kind: ReflectKind,
         to_kind: ReflectKind,
     },
 
-    #[error("enum variant `{variant_name}` doesn't have a field named `{field_name}`")]
+    #[display("enum variant `{variant_name}` doesn't have a field named `{field_name}`")]
     /// Enum variant that we tried to apply to was missing a field.
     MissingEnumField {
         variant_name: Box<str>,
         field_name: Box<str>,
     },
 
-    #[error("`{from_type}` is not `{to_type}`")]
+    #[display("`{from_type}` is not `{to_type}`")]
     /// Tried to apply incompatible types.
     MismatchedTypes {
         from_type: Box<str>,
         to_type: Box<str>,
     },
 
-    #[error("attempted to apply type with {from_size} size to a type with {to_size} size")]
+    #[display("attempted to apply type with {from_size} size to a type with {to_size} size")]
     /// Attempted to apply to types with mismatched sizez, e.g. a [u8; 4] to [u8; 3].
     DifferentSize { from_size: usize, to_size: usize },
 
-    #[error("variant with name `{variant_name}` does not exist on enum `{enum_name}`")]
+    #[display("variant with name `{variant_name}` does not exist on enum `{enum_name}`")]
     /// The enum we tried to apply to didn't contain a variant with the give name.
     UnknownVariant {
         enum_name: Box<str>,

crates/bevy_reflect/src/type_info.rs

@@ -8,7 +8,7 @@ use core::{
     fmt::{Debug, Formatter},
     hash::Hash,
 };
-use thiserror::Error;
+use derive_more::derive::{Display, Error};
 
 /// A static accessor to compile-time type information.
 ///
@@ -163,12 +163,12 @@ impl<T: Typed> DynamicTyped for T {
 }
 
 /// A [`TypeInfo`]-specific error.
-#[derive(Debug, Error)]
+#[derive(Debug, Error, Display)]
 pub enum TypeInfoError {
     /// Caused when a type was expected to be of a certain [kind], but was not.
     ///
     /// [kind]: ReflectKind
-    #[error("kind mismatch: expected {expected:?}, received {received:?}")]
+    #[display("kind mismatch: expected {expected:?}, received {received:?}")]
     KindMismatch {
         expected: ReflectKind,
         received: ReflectKind,