FilteredResource returns a Result instead of a simple Option

crates/bevy_ecs/src/reflect/resource.rs

@@ -8,7 +8,10 @@ use crate::{
     change_detection::Mut,
     component::ComponentId,
     resource::Resource,
-    world::{unsafe_world_cell::UnsafeWorldCell, FilteredResources, FilteredResourcesMut, World},
+    world::{
+        error::ResourceFetchError, unsafe_world_cell::UnsafeWorldCell, FilteredResources,
+        FilteredResourcesMut, World,
+    },
 };
 use bevy_reflect::{FromReflect, FromType, PartialReflect, Reflect, TypePath, TypeRegistry};
 
@@ -52,7 +55,8 @@ pub struct ReflectResourceFns {
     /// Function pointer implementing [`ReflectResource::remove()`].
     pub remove: fn(&mut World),
     /// Function pointer implementing [`ReflectResource::reflect()`].
-    pub reflect: for<'w> fn(FilteredResources<'w, '_>) -> Option<&'w dyn Reflect>,
+    pub reflect:
+        for<'w> fn(FilteredResources<'w, '_>) -> Result<&'w dyn Reflect, ResourceFetchError>,
     /// Function pointer implementing [`ReflectResource::reflect_mut()`].
     pub reflect_mut: for<'w> fn(FilteredResourcesMut<'w, '_>) -> Option<Mut<'w, dyn Reflect>>,
     /// Function pointer implementing [`ReflectResource::reflect_unchecked_mut()`].
@@ -118,7 +122,7 @@ impl ReflectResource {
     pub fn reflect<'w, 's>(
         &self,
         resources: impl Into<FilteredResources<'w, 's>>,
-    ) -> Option<&'w dyn Reflect> {
+    ) -> Result<&'w dyn Reflect, ResourceFetchError> {
         (self.0.reflect)(resources.into())
     }
 

crates/bevy_ecs/src/world/error.rs

@@ -55,3 +55,14 @@ pub enum EntityMutableFetchError {
     #[error("The entity with ID {0} was requested mutably more than once")]
     AliasedMutability(Entity),
 }
+
+/// An error that occurs when getting a resource of a given type in a world.
+#[derive(thiserror::Error, Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ResourceFetchError {
+    /// The resource does not exist in the world.
+    #[error("The resource does not exist in the world.")]
+    MissingResource,
+    /// No access to the resource with the given [`ComponentId`] in the world.
+    #[error("No access to the resource with ID {0:?} in the world.")]
+    NoResourceAccess(ComponentId),
+}

crates/bevy_ecs/src/world/filtered_resource.rs

@@ -7,6 +7,8 @@ use crate::{
 };
 use bevy_ptr::{Ptr, UnsafeCellDeref};
 
+use super::error::ResourceFetchError;
+
 /// Provides read-only access to a set of [`Resource`]s defined by the contained [`Access`].
 ///
 /// Use [`FilteredResourcesMut`] if you need mutable access to some resources.
@@ -151,21 +153,27 @@ impl<'w, 's> FilteredResources<'w, 's> {
     }
 
     /// Gets a reference to the resource of the given type if it exists and the `FilteredResources` has access to it.
-    pub fn get<R: Resource>(&self) -> Option<Ref<'w, R>> {
-        let component_id = self.world.components().resource_id::<R>()?;
+    pub fn get<R: Resource>(&self) -> Result<Ref<'w, R>, ResourceFetchError> {
+        let component_id = self
+            .world
+            .components()
+            .resource_id::<R>()
+            .ok_or(ResourceFetchError::MissingResource)?;
         if !self.access.has_resource_read(component_id) {
-            return None;
+            return Err(ResourceFetchError::NoResourceAccess(component_id));
         }
+
         // SAFETY: We have read access to this resource
-        unsafe { self.world.get_resource_with_ticks(component_id) }.map(|(value, ticks, caller)| {
-            Ref {
-                // SAFETY: `component_id` was obtained from the type ID of `R`.
-                value: unsafe { value.deref() },
-                // SAFETY: We have read access to the resource, so no mutable reference can exist.
-                ticks: unsafe { Ticks::from_tick_cells(ticks, self.last_run, self.this_run) },
-                // SAFETY: We have read access to the resource, so no mutable reference can exist.
-                changed_by: unsafe { caller.map(|caller| caller.deref()) },
-            }
+        let (value, ticks, caller) = unsafe { self.world.get_resource_with_ticks(component_id) }
+            .ok_or(ResourceFetchError::MissingResource)?;
+
+        Ok(Ref {
+            // SAFETY: `component_id` was obtained from the type ID of `R`.
+            value: unsafe { value.deref() },
+            // SAFETY: We have read access to the resource, so no mutable reference can exist.
+            ticks: unsafe { Ticks::from_tick_cells(ticks, self.last_run, self.this_run) },
+            // SAFETY: We have read access to the resource, so no mutable reference can exist.
+            changed_by: unsafe { caller.map(|caller| caller.deref()) },
         })
     }
 
@@ -419,7 +427,7 @@ impl<'w, 's> FilteredResourcesMut<'w, 's> {
     }
 
     /// Gets a reference to the resource of the given type if it exists and the `FilteredResources` has access to it.
-    pub fn get<R: Resource>(&self) -> Option<Ref<'_, R>> {
+    pub fn get<R: Resource>(&self) -> Result<Ref<'_, R>, ResourceFetchError> {
         self.as_readonly().get()
     }
 

crates/bevy_scene/src/dynamic_scene_builder.rs

@@ -381,7 +381,8 @@ impl<'w> DynamicSceneBuilder<'w> {
 
                 let resource = type_registration
                     .data::<ReflectResource>()?
-                    .reflect(self.original_world)?;
+                    .reflect(self.original_world)
+                    .ok()?;
 
                 let resource = type_registration
                     .data::<ReflectFromReflect>()