fix: Error on immediate load of self asset path.

Warn on deferred load of self asset path.

feat: Permit read_asset_bytes for self dep.

Don't record a loader_dependency for it, however.

style: Reformat.

Author: shanecelis

crates/bevy_asset/src/lib.rs

@@ -1997,7 +1997,8 @@ mod tests {
                 load_context: &mut LoadContext<'_>,
             ) -> Result<Self::Asset, Self::Error> {
                 let asset_path = load_context.asset_path().clone();
-                let loaded_asset = load_context.loader()
+                let loaded_asset = load_context
+                    .loader()
                     .immediate()
                     .load::<TestAsset>(asset_path)
                     .await?;
@@ -2018,7 +2019,11 @@ mod tests {
         run_app_until(&mut app, |_world| match asset_server.load_state(&handle) {
             LoadState::Loading => None,
             LoadState::Failed(err) => {
-                assert!(format!("{:?}", &err).contains("AssetDependentOnSelf"), "Error did not contain AssetDependentOnSelf: {:?}", &err);
+                assert!(
+                    format!("{:?}", &err).contains("AssetDependentOnSelf"),
+                    "Error did not contain AssetDependentOnSelf: {:?}",
+                    &err
+                );
                 Some(())
             }
             state => panic!("Unexpected asset state: {state:?}"),
@@ -2046,7 +2051,8 @@ mod tests {
                 load_context: &mut LoadContext<'_>,
             ) -> Result<Self::Asset, Self::Error> {
                 let asset_path = load_context.asset_path().clone();
-                let loaded_asset = load_context.loader()
+                let loaded_asset = load_context
+                    .loader()
                     .immediate()
                     .with_unknown_type()
                     .load(asset_path)
@@ -2071,7 +2077,11 @@ mod tests {
         run_app_until(&mut app, |_world| match asset_server.load_state(&handle) {
             LoadState::Loading => None,
             LoadState::Failed(err) => {
-                assert!(format!("{:?}", &err).contains("AssetDependentOnSelf"), "Error did not contain AssetDependentOnSelf: {:?}", &err);
+                assert!(
+                    format!("{:?}", &err).contains("AssetDependentOnSelf"),
+                    "Error did not contain AssetDependentOnSelf: {:?}",
+                    &err
+                );
                 Some(())
             }
             state => panic!("Unexpected asset state: {state:?}"),
@@ -2141,7 +2151,7 @@ mod tests {
                 messages,
                 [
                     AssetEvent::LoadedWithDependencies { id: handle.id() },
-                    AssetEvent::Added  { id: handle.id() }
+                    AssetEvent::Added { id: handle.id() }
                 ]
             );
             Some(())
@@ -2283,7 +2293,8 @@ mod tests {
                 let untyped_handle: UntypedHandle = load_context
                     .loader()
                     .with_unknown_type()
-                    .load(asset_path).into();
+                    .load(asset_path)
+                    .into();
 
                 Ok(TestAssetUD(untyped_handle))
             }
@@ -2320,7 +2331,7 @@ mod tests {
                 messages,
                 [
                     AssetEvent::LoadedWithDependencies { id: handle.id() },
-                    AssetEvent::Added  { id: handle.id() }
+                    AssetEvent::Added { id: handle.id() }
                 ]
             );
             Some(())

crates/bevy_asset/src/loader.rs

@@ -306,12 +306,14 @@ pub enum LoadDirectError {
         error: AssetLoadError,
     },
     #[error(transparent)]
-    AssetDependentOnSelf(#[from] AssetDependentOnSelf)
+    AssetDependentOnSelf(#[from] AssetDependentOnSelf),
 }
 
 #[derive(Error, Debug, Clone)]
 #[error("The asset at path `{}` loads itself as a dependent.", asset_path)]
-pub struct AssetDependentOnSelf { pub asset_path: AssetPath<'static> }
+pub struct AssetDependentOnSelf {
+    pub asset_path: AssetPath<'static>,
+}
 
 /// An error that occurs while deserializing [`AssetMeta`].
 #[derive(Error, Debug, Clone, PartialEq, Eq)]
@@ -514,7 +516,9 @@ impl<'a> LoadContext<'a> {
                 path: path.path().to_path_buf(),
                 source,
             })?;
-        self.loader_dependencies.insert(path.clone_owned(), hash);
+        if self.asset_path != path {
+            self.loader_dependencies.insert(path.clone_owned(), hash);
+        }
         Ok(bytes)
     }
 
@@ -540,6 +544,12 @@ impl<'a> LoadContext<'a> {
         loader: &dyn ErasedAssetLoader,
         reader: &mut dyn Reader,
     ) -> Result<ErasedLoadedAsset, LoadDirectError> {
+        if self.asset_path == path {
+            return Err(AssetDependentOnSelf {
+                asset_path: self.asset_path.clone_owned(),
+            }
+            .into());
+        }
         let loaded_asset = self
             .asset_server
             .load_with_meta_loader_and_reader(
@@ -557,6 +567,7 @@ impl<'a> LoadContext<'a> {
             })?;
         let info = meta.processed_info().as_ref();
         let hash = info.map(|i| i.full_hash).unwrap_or_default();
+
         self.loader_dependencies.insert(path, hash);
         Ok(loaded_asset)
     }
@@ -600,5 +611,5 @@ pub enum ReadAssetBytesError {
     #[error("The LoadContext for this read_asset_bytes call requires hash metadata, but it was not provided. This is likely an internal implementation error.")]
     MissingAssetHash,
     #[error(transparent)]
-    AssetDependentOnSelf(#[from] AssetDependentOnSelf)
+    AssetDependentOnSelf(#[from] AssetDependentOnSelf),
 }

crates/bevy_asset/src/loader_builders.rs

@@ -4,11 +4,12 @@
 use crate::{
     io::Reader,
     meta::{meta_transform_settings, AssetMetaDyn, MetaTransform, Settings},
-    Asset, AssetLoadError, AssetPath, ErasedAssetLoader, ErasedLoadedAsset, Handle, LoadContext,
-    LoadDirectError, LoadedAsset, LoadedUntypedAsset, UntypedHandle,
+    Asset, AssetDependentOnSelf, AssetLoadError, AssetPath, ErasedAssetLoader, ErasedLoadedAsset,
+    Handle, LoadContext, LoadDirectError, LoadedAsset, LoadedUntypedAsset, UntypedHandle,
 };
 use alloc::{borrow::ToOwned, boxed::Box, sync::Arc};
 use core::any::TypeId;
+use tracing::warn;
 
 // Utility type for handling the sources of reader references
 enum ReaderRef<'a> {
@@ -304,6 +305,8 @@ impl NestedLoader<'_, '_, StaticTyped, Deferred> {
     /// [`with_unknown_type`]: Self::with_unknown_type
     pub fn load<'c, A: Asset>(self, path: impl Into<AssetPath<'c>>) -> Handle<A> {
         let path = path.into().to_owned();
+
+        let is_self_path = *self.load_context.asset_path() == path;
         let handle = if self.load_context.should_load_dependencies {
             self.load_context.asset_server.load_with_meta_transform(
                 path,
@@ -318,8 +321,15 @@ impl NestedLoader<'_, '_, StaticTyped, Deferred> {
         };
         // `load_with_meta_transform` and `get_or_create_path_handle` always returns a Strong
         // variant, so we are safe to unwrap.
-        let index = (&handle).try_into().unwrap();
-        self.load_context.dependencies.insert(index);
+        if !is_self_path {
+            let index = (&handle).try_into().unwrap();
+            self.load_context.dependencies.insert(index);
+        } else {
+            warn!(
+                "Asset from path `{}` loaded the same path as a dependent, ignoring.",
+                self.load_context.asset_path()
+            );
+        }
         handle
     }
 }
@@ -367,6 +377,7 @@ impl NestedLoader<'_, '_, UnknownTyped, Deferred> {
     /// This will infer the asset type from metadata.
     pub fn load<'p>(self, path: impl Into<AssetPath<'p>>) -> Handle<LoadedUntypedAsset> {
         let path = path.into().to_owned();
+        let is_self_path = *self.load_context.asset_path() == path;
         let handle = if self.load_context.should_load_dependencies {
             self.load_context
                 .asset_server
@@ -379,7 +390,12 @@ impl NestedLoader<'_, '_, UnknownTyped, Deferred> {
         // `load_unknown_type_with_meta_transform` and `get_or_create_path_handle` always returns a
         // Strong variant, so we are safe to unwrap.
         let index = (&handle).try_into().unwrap();
-        self.load_context.dependencies.insert(index);
+
+        if !is_self_path {
+            self.load_context.dependencies.insert(index);
+        } else {
+            warn!("Asset from path `{}` of unknown type loaded the same path as a dependent, ignoring.", self.load_context.asset_path());
+        }
         handle
     }
 }
@@ -402,6 +418,12 @@ impl<'builder, 'reader, T> NestedLoader<'_, '_, T, Immediate<'builder, 'reader>>
         if path.label().is_some() {
             return Err(LoadDirectError::RequestedSubasset(path.clone()));
         }
+        if self.load_context.asset_path() == path {
+            return Err(AssetDependentOnSelf {
+                asset_path: path.clone(),
+            }
+            .into());
+        }
         self.load_context
             .asset_server
             .write_infos()