Remove incorrect equality comparisons for asset load error types

crates/bevy_asset/src/lib.rs

@@ -617,8 +617,7 @@ mod tests {
         },
         loader::{AssetLoader, LoadContext},
         Asset, AssetApp, AssetEvent, AssetId, AssetLoadError, AssetLoadFailedEvent, AssetPath,
-        AssetPlugin, AssetServer, Assets, DependencyLoadState, LoadState,
-        RecursiveDependencyLoadState,
+        AssetPlugin, AssetServer, Assets,
     };
     use alloc::sync::Arc;
     use bevy_app::{App, Update};
@@ -905,17 +904,9 @@ mod tests {
             let a_text = get::<CoolText>(app.world(), a_id);
             let (a_load, a_deps, a_rec_deps) = asset_server.get_load_states(a_id).unwrap();
             assert!(a_text.is_none(), "a's asset should not exist yet");
-            assert_eq!(a_load, LoadState::Loading, "a should still be loading");
-            assert_eq!(
-                a_deps,
-                DependencyLoadState::Loading,
-                "a deps should still be loading"
-            );
-            assert_eq!(
-                a_rec_deps,
-                RecursiveDependencyLoadState::Loading,
-                "a recursive deps should still be loading"
-            );
+            assert!(a_load.is_loading());
+            assert!(a_deps.is_loading());
+            assert!(a_rec_deps.is_loading());
         }
 
         // Allow "a" to load ... wait for it to finish loading and validate results
@@ -926,25 +917,25 @@ mod tests {
             let (a_load, a_deps, a_rec_deps) = asset_server.get_load_states(a_id).unwrap();
             assert_eq!(a_text.text, "a");
             assert_eq!(a_text.dependencies.len(), 2);
-            assert_eq!(a_load, LoadState::Loaded, "a is loaded");
-            assert_eq!(a_deps, DependencyLoadState::Loading);
-            assert_eq!(a_rec_deps, RecursiveDependencyLoadState::Loading);
+            assert!(a_load.is_loaded());
+            assert!(a_deps.is_loading());
+            assert!(a_rec_deps.is_loading());
 
             let b_id = a_text.dependencies[0].id();
             let b_text = get::<CoolText>(world, b_id);
             let (b_load, b_deps, b_rec_deps) = asset_server.get_load_states(b_id).unwrap();
             assert!(b_text.is_none(), "b component should not exist yet");
-            assert_eq!(b_load, LoadState::Loading);
-            assert_eq!(b_deps, DependencyLoadState::Loading);
-            assert_eq!(b_rec_deps, RecursiveDependencyLoadState::Loading);
+            assert!(b_load.is_loading());
+            assert!(b_deps.is_loading());
+            assert!(b_rec_deps.is_loading());
 
             let c_id = a_text.dependencies[1].id();
             let c_text = get::<CoolText>(world, c_id);
             let (c_load, c_deps, c_rec_deps) = asset_server.get_load_states(c_id).unwrap();
             assert!(c_text.is_none(), "c component should not exist yet");
-            assert_eq!(c_load, LoadState::Loading);
-            assert_eq!(c_deps, DependencyLoadState::Loading);
-            assert_eq!(c_rec_deps, RecursiveDependencyLoadState::Loading);
+            assert!(c_load.is_loading());
+            assert!(c_deps.is_loading());
+            assert!(c_rec_deps.is_loading());
             Some(())
         });
 
@@ -956,25 +947,25 @@ mod tests {
             let (a_load, a_deps, a_rec_deps) = asset_server.get_load_states(a_id).unwrap();
             assert_eq!(a_text.text, "a");
             assert_eq!(a_text.dependencies.len(), 2);
-            assert_eq!(a_load, LoadState::Loaded);
-            assert_eq!(a_deps, DependencyLoadState::Loading);
-            assert_eq!(a_rec_deps, RecursiveDependencyLoadState::Loading);
+            assert!(a_load.is_loaded());
+            assert!(a_deps.is_loading());
+            assert!(a_rec_deps.is_loading());
 
             let b_id = a_text.dependencies[0].id();
             let b_text = get::<CoolText>(world, b_id)?;
             let (b_load, b_deps, b_rec_deps) = asset_server.get_load_states(b_id).unwrap();
             assert_eq!(b_text.text, "b");
-            assert_eq!(b_load, LoadState::Loaded);
-            assert_eq!(b_deps, DependencyLoadState::Loaded);
-            assert_eq!(b_rec_deps, RecursiveDependencyLoadState::Loaded);
+            assert!(b_load.is_loaded());
+            assert!(b_deps.is_loaded());
+            assert!(b_rec_deps.is_loaded());
 
             let c_id = a_text.dependencies[1].id();
             let c_text = get::<CoolText>(world, c_id);
             let (c_load, c_deps, c_rec_deps) = asset_server.get_load_states(c_id).unwrap();
             assert!(c_text.is_none(), "c component should not exist yet");
-            assert_eq!(c_load, LoadState::Loading);
-            assert_eq!(c_deps, DependencyLoadState::Loading);
-            assert_eq!(c_rec_deps, RecursiveDependencyLoadState::Loading);
+            assert!(c_load.is_loading());
+            assert!(c_deps.is_loading());
+            assert!(c_rec_deps.is_loading());
             Some(())
         });
 
@@ -991,31 +982,29 @@ mod tests {
             assert_eq!(a_text.text, "a");
             assert_eq!(a_text.embedded, "");
             assert_eq!(a_text.dependencies.len(), 2);
-            assert_eq!(a_load, LoadState::Loaded);
+            assert!(a_load.is_loaded());
 
             let b_id = a_text.dependencies[0].id();
             let b_text = get::<CoolText>(world, b_id)?;
             let (b_load, b_deps, b_rec_deps) = asset_server.get_load_states(b_id).unwrap();
             assert_eq!(b_text.text, "b");
             assert_eq!(b_text.embedded, "");
-            assert_eq!(b_load, LoadState::Loaded);
-            assert_eq!(b_deps, DependencyLoadState::Loaded);
-            assert_eq!(b_rec_deps, RecursiveDependencyLoadState::Loaded);
+            assert!(b_load.is_loaded());
+            assert!(b_deps.is_loaded());
+            assert!(b_rec_deps.is_loaded());
 
             let c_id = a_text.dependencies[1].id();
             let c_text = get::<CoolText>(world, c_id)?;
             let (c_load, c_deps, c_rec_deps) = asset_server.get_load_states(c_id).unwrap();
             assert_eq!(c_text.text, "c");
             assert_eq!(c_text.embedded, "ab");
-            assert_eq!(c_load, LoadState::Loaded);
-            assert_eq!(
-                c_deps,
-                DependencyLoadState::Loading,
+            assert!(c_load.is_loaded());
+            assert!(
+                c_deps.is_loading(),
                 "c deps should not be loaded yet because d has not loaded"
             );
-            assert_eq!(
-                c_rec_deps,
-                RecursiveDependencyLoadState::Loading,
+            assert!(
+                c_rec_deps.is_loading(),
                 "c rec deps should not be loaded yet because d has not loaded"
             );
 
@@ -1025,26 +1014,24 @@ mod tests {
             assert_eq!(sub_text.text, "hello");
             let (sub_text_load, sub_text_deps, sub_text_rec_deps) =
                 asset_server.get_load_states(sub_text_id).unwrap();
-            assert_eq!(sub_text_load, LoadState::Loaded);
-            assert_eq!(sub_text_deps, DependencyLoadState::Loaded);
-            assert_eq!(sub_text_rec_deps, RecursiveDependencyLoadState::Loaded);
+            assert!(sub_text_load.is_loaded());
+            assert!(sub_text_deps.is_loaded());
+            assert!(sub_text_rec_deps.is_loaded());
 
             let d_id = c_text.dependencies[0].id();
             let d_text = get::<CoolText>(world, d_id);
             let (d_load, d_deps, d_rec_deps) = asset_server.get_load_states(d_id).unwrap();
             assert!(d_text.is_none(), "d component should not exist yet");
-            assert_eq!(d_load, LoadState::Loading);
-            assert_eq!(d_deps, DependencyLoadState::Loading);
-            assert_eq!(d_rec_deps, RecursiveDependencyLoadState::Loading);
+            assert!(d_load.is_loading());
+            assert!(d_deps.is_loading());
+            assert!(d_rec_deps.is_loading());
 
-            assert_eq!(
-                a_deps,
-                DependencyLoadState::Loaded,
+            assert!(
+                a_deps.is_loaded(),
                 "If c has been loaded, the a deps should all be considered loaded"
             );
-            assert_eq!(
-                a_rec_deps,
-                RecursiveDependencyLoadState::Loading,
+            assert!(
+                a_rec_deps.is_loading(),
                 "d is not loaded, so a's recursive deps should still be loading"
             );
             world.insert_resource(IdResults { b_id, c_id, d_id });
@@ -1067,17 +1054,16 @@ mod tests {
             assert_eq!(d_text.text, "d");
             assert_eq!(d_text.embedded, "");
 
-            assert_eq!(c_load, LoadState::Loaded);
-            assert_eq!(c_deps, DependencyLoadState::Loaded);
-            assert_eq!(c_rec_deps, RecursiveDependencyLoadState::Loaded);
+            assert!(c_load.is_loaded());
+            assert!(c_deps.is_loaded());
+            assert!(c_rec_deps.is_loaded());
 
-            assert_eq!(d_load, LoadState::Loaded);
-            assert_eq!(d_deps, DependencyLoadState::Loaded);
-            assert_eq!(d_rec_deps, RecursiveDependencyLoadState::Loaded);
+            assert!(d_load.is_loaded());
+            assert!(d_deps.is_loaded());
+            assert!(d_rec_deps.is_loaded());
 
-            assert_eq!(
-                a_rec_deps,
-                RecursiveDependencyLoadState::Loaded,
+            assert!(
+                a_rec_deps.is_loaded(),
                 "d is loaded, so a's recursive deps should be loaded"
             );
             Some(())
@@ -1245,49 +1231,37 @@ mod tests {
             let d_id = c_text.dependencies[0].id();
             let d_text = get::<CoolText>(world, d_id);
             let (d_load, d_deps, d_rec_deps) = asset_server.get_load_states(d_id).unwrap();
-            if !matches!(d_load, LoadState::Failed(_)) {
+
+            if !d_load.is_failed() {
                 // wait until d has exited the loading state
                 return None;
             }
 
             assert!(d_text.is_none());
-            assert!(matches!(d_load, LoadState::Failed(_)));
-            assert!(matches!(d_deps, DependencyLoadState::Failed(_)));
-            assert!(matches!(
-                d_rec_deps,
-                RecursiveDependencyLoadState::Failed(_)
-            ));
+            assert!(d_load.is_failed());
+            assert!(d_deps.is_failed());
+            assert!(d_rec_deps.is_failed());
 
             assert_eq!(a_text.text, "a");
-            assert_eq!(a_load, LoadState::Loaded);
-            assert_eq!(a_deps, DependencyLoadState::Loaded);
-            assert!(matches!(
-                a_rec_deps,
-                RecursiveDependencyLoadState::Failed(_)
-            ));
+            assert!(a_load.is_loaded());
+            assert!(a_deps.is_loaded());
+            assert!(a_rec_deps.is_failed());
 
             assert_eq!(b_text.text, "b");
-            assert_eq!(b_load, LoadState::Loaded);
-            assert_eq!(b_deps, DependencyLoadState::Loaded);
-            assert_eq!(b_rec_deps, RecursiveDependencyLoadState::Loaded);
+            assert!(b_load.is_loaded());
+            assert!(b_deps.is_loaded());
+            assert!(b_rec_deps.is_loaded());
 
             assert_eq!(c_text.text, "c");
-            assert_eq!(c_load, LoadState::Loaded);
-            assert!(matches!(c_deps, DependencyLoadState::Failed(_)));
-            assert!(matches!(
-                c_rec_deps,
-                RecursiveDependencyLoadState::Failed(_)
-            ));
-
-            assert_eq!(asset_server.load_state(a_id), LoadState::Loaded);
-            assert_eq!(
-                asset_server.dependency_load_state(a_id),
-                DependencyLoadState::Loaded
-            );
-            assert!(matches!(
-                asset_server.recursive_dependency_load_state(a_id),
-                RecursiveDependencyLoadState::Failed(_)
-            ));
+            assert!(c_load.is_loaded());
+            assert!(c_deps.is_failed());
+            assert!(c_rec_deps.is_failed());
+
+            assert!(asset_server.load_state(a_id).is_loaded());
+            assert!(asset_server.dependency_load_state(a_id).is_loaded());
+            assert!(asset_server
+                .recursive_dependency_load_state(a_id)
+                .is_failed());
 
             assert!(asset_server.is_loaded(a_id));
             assert!(asset_server.is_loaded_with_direct_dependencies(a_id));
@@ -1349,9 +1323,9 @@ mod tests {
         run_app_until(&mut app, |world| {
             let _a_text = get::<CoolText>(world, a_id)?;
             let (a_load, a_deps, a_rec_deps) = asset_server.get_load_states(a_id).unwrap();
-            assert_eq!(a_load, LoadState::Loaded);
-            assert_eq!(a_deps, DependencyLoadState::Loading);
-            assert_eq!(a_rec_deps, RecursiveDependencyLoadState::Loading);
+            assert!(a_load.is_loaded());
+            assert!(a_deps.is_loading());
+            assert!(a_rec_deps.is_loading());
             Some(())
         });
 
@@ -1361,18 +1335,15 @@ mod tests {
             let b_id = a_text.dependencies[0].id();
 
             let (b_load, _b_deps, _b_rec_deps) = asset_server.get_load_states(b_id).unwrap();
-            if !matches!(b_load, LoadState::Failed(_)) {
+            if !b_load.is_failed() {
                 // wait until b fails
                 return None;
             }
 
             let (a_load, a_deps, a_rec_deps) = asset_server.get_load_states(a_id).unwrap();
-            assert_eq!(a_load, LoadState::Loaded);
-            assert!(matches!(a_deps, DependencyLoadState::Failed(_)));
-            assert!(matches!(
-                a_rec_deps,
-                RecursiveDependencyLoadState::Failed(_)
-            ));
+            assert!(a_load.is_loaded());
+            assert!(a_deps.is_failed());
+            assert!(a_rec_deps.is_failed());
             Some(())
         });
 
@@ -1384,13 +1355,13 @@ mod tests {
             let _c_text = get::<CoolText>(world, c_id)?;
 
             let (a_load, a_deps, a_rec_deps) = asset_server.get_load_states(a_id).unwrap();
-            assert_eq!(a_load, LoadState::Loaded);
+            assert!(a_load.is_loaded());
             assert!(
-                matches!(a_deps, DependencyLoadState::Failed(_)),
+                a_deps.is_failed(),
                 "Successful dependency load should not overwrite a previous failure"
             );
             assert!(
-                matches!(a_rec_deps, RecursiveDependencyLoadState::Failed(_)),
+                a_rec_deps.is_failed(),
                 "Successful dependency load should not overwrite a previous failure"
             );
             Some(())
@@ -1681,7 +1652,7 @@ mod tests {
             // Check what just failed
             for error in errors.read() {
                 let (load_state, _, _) = server.get_load_states(error.id).unwrap();
-                assert!(matches!(load_state, LoadState::Failed(_)));
+                assert!(load_state.is_failed());
                 assert_eq!(*error.path.source(), AssetSourceId::Name("unstable".into()));
                 match &error.error {
                     AssetLoadError::AssetReaderError(read_error) => match read_error {

crates/bevy_asset/src/server/info.rs

@@ -498,16 +498,14 @@ impl AssetInfos {
                 info.loader_dependencies = loaded_asset.loader_dependencies;
             }
 
-            let dependants_waiting_on_rec_load = if matches!(
-                rec_dep_load_state,
-                RecursiveDependencyLoadState::Loaded | RecursiveDependencyLoadState::Failed(_)
-            ) {
-                Some(core::mem::take(
-                    &mut info.dependants_waiting_on_recursive_dep_load,
-                ))
-            } else {
-                None
-            };
+            let dependants_waiting_on_rec_load =
+                if rec_dep_load_state.is_loaded() || rec_dep_load_state.is_failed() {
+                    Some(core::mem::take(
+                        &mut info.dependants_waiting_on_recursive_dep_load,
+                    ))
+                } else {
+                    None
+                };
 
             (
                 core::mem::take(&mut info.dependants_waiting_on_load),
@@ -518,9 +516,7 @@ impl AssetInfos {
         for id in dependants_waiting_on_load {
             if let Some(info) = self.get_mut(id) {
                 info.loading_dependencies.remove(&loaded_asset_id);
-                if info.loading_dependencies.is_empty()
-                    && !matches!(info.dep_load_state, DependencyLoadState::Failed(_))
-                {
+                if info.loading_dependencies.is_empty() && !info.dep_load_state.is_failed() {
                     // send dependencies loaded event
                     info.dep_load_state = DependencyLoadState::Loaded;
                 }
@@ -558,7 +554,7 @@ impl AssetInfos {
             info.loading_rec_dependencies.remove(&loaded_id);
             if info.loading_rec_dependencies.is_empty() && info.failed_rec_dependencies.is_empty() {
                 info.rec_dep_load_state = RecursiveDependencyLoadState::Loaded;
-                if info.load_state == LoadState::Loaded {
+                if info.load_state.is_loaded() {
                     sender
                         .send(InternalAssetEvent::LoadedWithDependencies { id: waiting_id })
                         .unwrap();
@@ -631,7 +627,7 @@ impl AssetInfos {
                 info.loading_dependencies.remove(&failed_id);
                 info.failed_dependencies.insert(failed_id);
                 // don't overwrite DependencyLoadState if already failed to preserve first error
-                if !(matches!(info.dep_load_state, DependencyLoadState::Failed(_))) {
+                if !info.dep_load_state.is_failed() {
                     info.dep_load_state = DependencyLoadState::Failed(error.clone());
                 }
             }