Remove thiserror from bevy_asset (#15778)

# Objective

- Contributes to #15460

## Solution

- Removed `thiserror` from `bevy_asset`

crates/bevy_asset/Cargo.toml

@@ -44,7 +44,11 @@ blake3 = "1.5"
 parking_lot = { version = "0.12", features = ["arc_lock", "send_guard"] }
 ron = "0.8"
 serde = { version = "1", features = ["derive"] }
-thiserror = "1.0"
+derive_more = { version = "1", default-features = false, features = [
+  "error",
+  "from",
+  "display",
+] }
 uuid = { version = "1.0", features = ["v4"] }
 
 [target.'cfg(target_os = "android")'.dependencies]

crates/bevy_asset/src/assets.rs

@@ -11,8 +11,8 @@ use bevy_reflect::{Reflect, TypePath};
 use bevy_utils::HashMap;
 use core::{any::TypeId, iter::Enumerate, marker::PhantomData, sync::atomic::AtomicU32};
 use crossbeam_channel::{Receiver, Sender};
+use derive_more::derive::{Display, Error};
 use serde::{Deserialize, Serialize};
-use thiserror::Error;
 use uuid::Uuid;
 
 /// A generational runtime-only identifier for a specific [`Asset`] stored in [`Assets`]. This is optimized for efficient runtime
@@ -613,8 +613,8 @@ impl<'a, A: Asset> Iterator for AssetsMutIterator<'a, A> {
     }
 }
 
-#[derive(Error, Debug)]
-#[error("AssetIndex {index:?} has an invalid generation. The current generation is: '{current_generation}'.")]
+#[derive(Error, Display, Debug)]
+#[display("AssetIndex {index:?} has an invalid generation. The current generation is: '{current_generation}'.")]
 pub struct InvalidGenerationError {
     index: AssetIndex,
     current_generation: u32,

crates/bevy_asset/src/handle.rs

@@ -10,8 +10,8 @@ use core::{
     hash::{Hash, Hasher},
 };
 use crossbeam_channel::{Receiver, Sender};
+use derive_more::derive::{Display, Error};
 use disqualified::ShortName;
-use thiserror::Error;
 use uuid::Uuid;
 
 /// Provides [`Handle`] and [`UntypedHandle`] _for a specific asset type_.
@@ -503,11 +503,11 @@ impl<A: Asset> TryFrom<UntypedHandle> for Handle<A> {
 }
 
 /// Errors preventing the conversion of to/from an [`UntypedHandle`] and a [`Handle`].
-#[derive(Error, Debug, PartialEq, Clone)]
+#[derive(Error, Display, Debug, PartialEq, Clone)]
 #[non_exhaustive]
 pub enum UntypedAssetConversionError {
     /// Caused when trying to convert an [`UntypedHandle`] into a [`Handle`] of the wrong type.
-    #[error(
+    #[display(
         "This UntypedHandle is for {found:?} and cannot be converted into a Handle<{expected:?}>"
     )]
     TypeIdMismatch { expected: TypeId, found: TypeId },

crates/bevy_asset/src/id.rs

@@ -9,15 +9,15 @@ use core::{
     hash::Hash,
     marker::PhantomData,
 };
-use thiserror::Error;
+use derive_more::derive::{Display, Error, From};
 
 /// A unique runtime-only identifier for an [`Asset`]. This is cheap to [`Copy`]/[`Clone`] and is not directly tied to the
 /// lifetime of the Asset. This means it _can_ point to an [`Asset`] that no longer exists.
 ///
 /// For an identifier tied to the lifetime of an asset, see [`Handle`](`crate::Handle`).
 ///
 /// For an "untyped" / "generic-less" id, see [`UntypedAssetId`].
-#[derive(Reflect, Serialize, Deserialize)]
+#[derive(Reflect, Serialize, Deserialize, From)]
 pub enum AssetId<A: Asset> {
     /// A small / efficient runtime identifier that can be used to efficiently look up an asset stored in [`Assets`]. This is
     /// the "default" identifier used for assets. The alternative(s) (ex: [`AssetId::Uuid`]) will only be used if assets are
@@ -154,13 +154,6 @@ impl<A: Asset> From<AssetIndex> for AssetId<A> {
     }
 }
 
-impl<A: Asset> From<Uuid> for AssetId<A> {
-    #[inline]
-    fn from(value: Uuid) -> Self {
-        Self::Uuid { uuid: value }
-    }
-}
-
 /// An "untyped" / "generic-less" [`Asset`] identifier that behaves much like [`AssetId`], but stores the [`Asset`] type
 /// information at runtime instead of compile-time. This increases the size of the type, but it enables storing asset ids
 /// across asset types together and enables comparisons between them.
@@ -310,7 +303,7 @@ impl PartialOrd for UntypedAssetId {
 /// Do not _ever_ use this across asset types for comparison.
 /// [`InternalAssetId`] contains no type information and will happily collide
 /// with indices across types.
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash, PartialOrd, Ord)]
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash, PartialOrd, Ord, From)]
 pub(crate) enum InternalAssetId {
     Index(AssetIndex),
     Uuid(Uuid),
@@ -337,18 +330,6 @@ impl InternalAssetId {
     }
 }
 
-impl From<AssetIndex> for InternalAssetId {
-    fn from(value: AssetIndex) -> Self {
-        Self::Index(value)
-    }
-}
-
-impl From<Uuid> for InternalAssetId {
-    fn from(value: Uuid) -> Self {
-        Self::Uuid(value)
-    }
-}
-
 // Cross Operations
 
 impl<A: Asset> PartialEq<UntypedAssetId> for AssetId<A> {
@@ -417,11 +398,11 @@ impl<A: Asset> TryFrom<UntypedAssetId> for AssetId<A> {
 }
 
 /// Errors preventing the conversion of to/from an [`UntypedAssetId`] and an [`AssetId`].
-#[derive(Error, Debug, PartialEq, Clone)]
+#[derive(Error, Display, Debug, PartialEq, Clone)]
 #[non_exhaustive]
 pub enum UntypedAssetIdConversionError {
     /// Caused when trying to convert an [`UntypedAssetId`] into an [`AssetId`] of the wrong type.
-    #[error("This UntypedAssetId is for {found:?} and cannot be converted into an AssetId<{expected:?}>")]
+    #[display("This UntypedAssetId is for {found:?} and cannot be converted into an AssetId<{expected:?}>")]
     TypeIdMismatch { expected: TypeId, found: TypeId },
 }
 

crates/bevy_asset/src/io/mod.rs

@@ -28,25 +28,27 @@ use core::{
     pin::Pin,
     task::{Context, Poll},
 };
+use derive_more::derive::{Display, Error, From};
 use futures_io::{AsyncRead, AsyncWrite};
 use futures_lite::{ready, Stream};
 use std::path::{Path, PathBuf};
-use thiserror::Error;
 
 /// Errors that occur while loading assets.
-#[derive(Error, Debug, Clone)]
+#[derive(Error, Display, Debug, Clone)]
 pub enum AssetReaderError {
     /// Path not found.
-    #[error("Path not found: {0}")]
+    #[display("Path not found: {}", _0.display())]
+    #[error(ignore)]
     NotFound(PathBuf),
 
     /// Encountered an I/O error while loading an asset.
-    #[error("Encountered an I/O error while loading asset: {0}")]
+    #[display("Encountered an I/O error while loading asset: {_0}")]
     Io(Arc<std::io::Error>),
 
     /// The HTTP request completed but returned an unhandled [HTTP response status code](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status).
     /// If the request fails before getting a status code (e.g. request timeout, interrupted connection, etc), expect [`AssetReaderError::Io`].
-    #[error("Encountered HTTP status {0:?} when loading asset")]
+    #[display("Encountered HTTP status {_0:?} when loading asset")]
+    #[error(ignore)]
     HttpError(u16),
 }
 
@@ -296,11 +298,11 @@ pub type Writer = dyn AsyncWrite + Unpin + Send + Sync;
 pub type PathStream = dyn Stream<Item = PathBuf> + Unpin + Send;
 
 /// Errors that occur while loading assets.
-#[derive(Error, Debug)]
+#[derive(Error, Display, Debug, From)]
 pub enum AssetWriterError {
     /// Encountered an I/O error while loading an asset.
-    #[error("encountered an io error while loading asset: {0}")]
-    Io(#[from] std::io::Error),
+    #[display("encountered an io error while loading asset: {_0}")]
+    Io(std::io::Error),
 }
 
 /// Preforms write operations on an asset storage. [`AssetWriter`] exposes a "virtual filesystem"

crates/bevy_asset/src/io/source.rs

@@ -10,7 +10,7 @@ use bevy_utils::{
     Duration, HashMap,
 };
 use core::{fmt::Display, hash::Hash};
-use thiserror::Error;
+use derive_more::derive::{Display, Error};
 
 use super::{ErasedAssetReader, ErasedAssetWriter};
 
@@ -629,23 +629,27 @@ impl AssetSources {
 }
 
 /// An error returned when an [`AssetSource`] does not exist for a given id.
-#[derive(Error, Debug, Clone, PartialEq, Eq)]
-#[error("Asset Source '{0}' does not exist")]
+#[derive(Error, Display, Debug, Clone, PartialEq, Eq)]
+#[display("Asset Source '{_0}' does not exist")]
+#[error(ignore)]
 pub struct MissingAssetSourceError(AssetSourceId<'static>);
 
 /// An error returned when an [`AssetWriter`](crate::io::AssetWriter) does not exist for a given id.
-#[derive(Error, Debug, Clone)]
-#[error("Asset Source '{0}' does not have an AssetWriter.")]
+#[derive(Error, Display, Debug, Clone)]
+#[display("Asset Source '{_0}' does not have an AssetWriter.")]
+#[error(ignore)]
 pub struct MissingAssetWriterError(AssetSourceId<'static>);
 
 /// An error returned when a processed [`AssetReader`](crate::io::AssetReader) does not exist for a given id.
-#[derive(Error, Debug, Clone, PartialEq, Eq)]
-#[error("Asset Source '{0}' does not have a processed AssetReader.")]
+#[derive(Error, Display, Debug, Clone, PartialEq, Eq)]
+#[display("Asset Source '{_0}' does not have a processed AssetReader.")]
+#[error(ignore)]
 pub struct MissingProcessedAssetReaderError(AssetSourceId<'static>);
 
 /// An error returned when a processed [`AssetWriter`](crate::io::AssetWriter) does not exist for a given id.
-#[derive(Error, Debug, Clone)]
-#[error("Asset Source '{0}' does not have a processed AssetWriter.")]
+#[derive(Error, Display, Debug, Clone)]
+#[display("Asset Source '{_0}' does not have a processed AssetWriter.")]
+#[error(ignore)]
 pub struct MissingProcessedAssetWriterError(AssetSourceId<'static>);
 
 const MISSING_DEFAULT_SOURCE: &str =

crates/bevy_asset/src/lib.rs

@@ -631,9 +631,9 @@ mod tests {
     use bevy_log::LogPlugin;
     use bevy_reflect::TypePath;
     use bevy_utils::{Duration, HashMap};
+    use derive_more::derive::{Display, Error, From};
     use serde::{Deserialize, Serialize};
     use std::path::Path;
-    use thiserror::Error;
 
     #[derive(Asset, TypePath, Debug, Default)]
     pub struct CoolText {
@@ -661,14 +661,14 @@ mod tests {
     #[derive(Default)]
     pub struct CoolTextLoader;
 
-    #[derive(Error, Debug)]
+    #[derive(Error, Display, Debug, From)]
     pub enum CoolTextLoaderError {
-        #[error("Could not load dependency: {dependency}")]
+        #[display("Could not load dependency: {dependency}")]
         CannotLoadDependency { dependency: AssetPath<'static> },
-        #[error("A RON error occurred during loading")]
-        RonSpannedError(#[from] ron::error::SpannedError),
-        #[error("An IO error occurred during loading")]
-        Io(#[from] std::io::Error),
+        #[display("A RON error occurred during loading")]
+        RonSpannedError(ron::error::SpannedError),
+        #[display("An IO error occurred during loading")]
+        Io(std::io::Error),
     }
 
     impl AssetLoader for CoolTextLoader {

crates/bevy_asset/src/loader.rs

@@ -10,11 +10,11 @@ use atomicow::CowArc;
 use bevy_ecs::world::World;
 use bevy_utils::{BoxedFuture, ConditionalSendFuture, HashMap, HashSet};
 use core::any::{Any, TypeId};
+use derive_more::derive::{Display, Error, From};
 use downcast_rs::{impl_downcast, Downcast};
 use ron::error::SpannedError;
 use serde::{Deserialize, Serialize};
 use std::path::{Path, PathBuf};
-use thiserror::Error;
 
 /// Loads an [`Asset`] from a given byte [`Reader`]. This can accept [`AssetLoader::Settings`], which configure how the [`Asset`]
 /// should be loaded.
@@ -295,19 +295,20 @@ impl<A: Asset> AssetContainer for A {
 ///
 /// [`NestedLoader::load`]: crate::NestedLoader::load
 /// [immediately]: crate::Immediate
-#[derive(Error, Debug)]
-#[error("Failed to load dependency {dependency:?} {error}")]
+#[derive(Error, Display, Debug)]
+#[display("Failed to load dependency {dependency:?} {error}")]
 pub struct LoadDirectError {
     pub dependency: AssetPath<'static>,
     pub error: AssetLoadError,
 }
 
 /// An error that occurs while deserializing [`AssetMeta`].
-#[derive(Error, Debug, Clone, PartialEq, Eq)]
+#[derive(Error, Display, Debug, Clone, PartialEq, Eq, From)]
 pub enum DeserializeMetaError {
-    #[error("Failed to deserialize asset meta: {0:?}")]
-    DeserializeSettings(#[from] SpannedError),
-    #[error("Failed to deserialize minimal asset meta: {0:?}")]
+    #[display("Failed to deserialize asset meta: {_0:?}")]
+    DeserializeSettings(SpannedError),
+    #[display("Failed to deserialize minimal asset meta: {_0:?}")]
+    #[from(ignore)]
     DeserializeMinimal(SpannedError),
 }
 
@@ -572,23 +573,18 @@ impl<'a> LoadContext<'a> {
 }
 
 /// An error produced when calling [`LoadContext::read_asset_bytes`]
-#[derive(Error, Debug)]
+#[derive(Error, Display, Debug, From)]
 pub enum ReadAssetBytesError {
-    #[error(transparent)]
-    DeserializeMetaError(#[from] DeserializeMetaError),
-    #[error(transparent)]
-    AssetReaderError(#[from] AssetReaderError),
-    #[error(transparent)]
-    MissingAssetSourceError(#[from] MissingAssetSourceError),
-    #[error(transparent)]
-    MissingProcessedAssetReaderError(#[from] MissingProcessedAssetReaderError),
+    DeserializeMetaError(DeserializeMetaError),
+    AssetReaderError(AssetReaderError),
+    MissingAssetSourceError(MissingAssetSourceError),
+    MissingProcessedAssetReaderError(MissingProcessedAssetReaderError),
     /// Encountered an I/O error while loading an asset.
-    #[error("Encountered an io error while loading asset at `{path}`: {source}")]
+    #[display("Encountered an io error while loading asset at `{}`: {source}", path.display())]
     Io {
         path: PathBuf,
-        #[source]
         source: std::io::Error,
     },
-    #[error("The LoadContext for this read_asset_bytes call requires hash metadata, but it was not provided. This is likely an internal implementation error.")]
+    #[display("The LoadContext for this read_asset_bytes call requires hash metadata, but it was not provided. This is likely an internal implementation error.")]
     MissingAssetHash,
 }

crates/bevy_asset/src/path.rs

@@ -6,9 +6,9 @@ use core::{
     hash::Hash,
     ops::Deref,
 };
+use derive_more::derive::{Display, Error};
 use serde::{de::Visitor, Deserialize, Serialize};
 use std::path::{Path, PathBuf};
-use thiserror::Error;
 
 /// Represents a path to an asset in a "virtual filesystem".
 ///
@@ -76,19 +76,19 @@ impl<'a> Display for AssetPath<'a> {
 }
 
 /// An error that occurs when parsing a string type to create an [`AssetPath`] fails, such as during [`AssetPath::parse`].
-#[derive(Error, Debug, PartialEq, Eq)]
+#[derive(Error, Display, Debug, PartialEq, Eq)]
 pub enum ParseAssetPathError {
     /// Error that occurs when the [`AssetPath::source`] section of a path string contains the [`AssetPath::label`] delimiter `#`. E.g. `bad#source://file.test`.
-    #[error("Asset source must not contain a `#` character")]
+    #[display("Asset source must not contain a `#` character")]
     InvalidSourceSyntax,
     /// Error that occurs when the [`AssetPath::label`] section of a path string contains the [`AssetPath::source`] delimiter `://`. E.g. `source://file.test#bad://label`.
-    #[error("Asset label must not contain a `://` substring")]
+    #[display("Asset label must not contain a `://` substring")]
     InvalidLabelSyntax,
     /// Error that occurs when a path string has an [`AssetPath::source`] delimiter `://` with no characters preceding it. E.g. `://file.test`.
-    #[error("Asset source must be at least one character. Either specify the source before the '://' or remove the `://`")]
+    #[display("Asset source must be at least one character. Either specify the source before the '://' or remove the `://`")]
     MissingSource,
     /// Error that occurs when a path string has an [`AssetPath::label`] delimiter `#` with no characters succeeding it. E.g. `file.test#`
-    #[error("Asset label must be at least one character. Either specify the label after the '#' or remove the '#'")]
+    #[display("Asset label must be at least one character. Either specify the label after the '#' or remove the '#'")]
     MissingLabel,
 }