add helping log when trying to access an entity that does not exist

crates/bevy_ecs/src/entity/mod.rs

@@ -164,6 +164,15 @@ pub struct Entities {
     len: u32,
 }
 
+/// Error getting the location of an entity.
+#[derive(Debug)]
+pub enum EntityLocationError {
+    /// This entity has not yet been spawned.
+    NotYetSpawned,
+    /// This entity has already been despawned.
+    AlreadyDespawned,
+}
+
 impl Entities {
     /// Reserve entity IDs concurrently
     ///
@@ -353,15 +362,16 @@ impl Entities {
     }
 
     /// Returns `Ok(Location { archetype: 0, index: undefined })` for pending entities
-    pub fn get(&self, entity: Entity) -> Option<EntityLocation> {
+    pub fn get(&self, entity: Entity) -> Result<EntityLocation, EntityLocationError> {
         if (entity.id as usize) < self.meta.len() {
             let meta = &self.meta[entity.id as usize];
-            if meta.generation != entity.generation {
-                return None;
+            match meta.generation.cmp(&entity.generation) {
+                std::cmp::Ordering::Equal => Ok(meta.location),
+                std::cmp::Ordering::Less => Err(EntityLocationError::NotYetSpawned),
+                std::cmp::Ordering::Greater => Err(EntityLocationError::AlreadyDespawned),
             }
-            Some(meta.location)
         } else {
-            None
+            Err(EntityLocationError::NotYetSpawned)
         }
     }
 

crates/bevy_ecs/src/query/state.rs

@@ -153,7 +153,7 @@ where
         let location = world
             .entities
             .get(entity)
-            .ok_or(QueryEntityError::NoSuchEntity)?;
+            .map_err(|_| QueryEntityError::NoSuchEntity)?;
         if !self
             .matched_archetypes
             .contains(location.archetype_id.index())

crates/bevy_ecs/src/world/mod.rs

@@ -19,6 +19,7 @@ use crate::{
     query::{FilterFetch, QueryState, WorldQuery},
     storage::{Column, SparseSet, Storages},
 };
+use bevy_utils::tracing::warn;
 use std::{
     any::TypeId,
     fmt,
@@ -237,7 +238,13 @@ impl World {
     /// ```
     #[inline]
     pub fn get_entity(&self, entity: Entity) -> Option<EntityRef> {
-        let location = self.entities.get(entity)?;
+        let location = match self.entities.get(entity) {
+            Ok(entity_location) => entity_location,
+            Err(err) => {
+                warn!("Error getting entity {:?}: {:?}", entity, err,);
+                return None;
+            }
+        };
         Some(EntityRef::new(self, entity, location))
     }
 
@@ -264,7 +271,13 @@ impl World {
     /// ```
     #[inline]
     pub fn get_entity_mut(&mut self, entity: Entity) -> Option<EntityMut> {
-        let location = self.entities.get(entity)?;
+        let location = match self.entities.get(entity) {
+            Ok(entity_location) => entity_location,
+            Err(err) => {
+                warn!("Error getting entity {:?}: {:?}", entity, err,);
+                return None;
+            }
+        };
         // SAFE: `entity` exists and `location` is that entity's location
         Some(unsafe { EntityMut::new(self, entity, location) })
     }
@@ -431,15 +444,15 @@ impl World {
     ///
     /// let mut world = World::new();
     /// let entities = world.spawn_batch(vec![
-    ///     (Position { x: 0.0, y: 0.0}, Velocity { x: 1.0, y: 0.0 }),    
-    ///     (Position { x: 0.0, y: 0.0}, Velocity { x: 0.0, y: 1.0 }),    
+    ///     (Position { x: 0.0, y: 0.0}, Velocity { x: 1.0, y: 0.0 }),
+    ///     (Position { x: 0.0, y: 0.0}, Velocity { x: 0.0, y: 1.0 }),
     /// ]).collect::<Vec<Entity>>();
     ///
     /// let mut query = world.query::<(&mut Position, &Velocity)>();
     /// for (mut position, velocity) in query.iter_mut(&mut world) {
     ///    position.x += velocity.x;
     ///    position.y += velocity.y;
-    /// }     
+    /// }
     ///
     /// assert_eq!(world.get::<Position>(entities[0]).unwrap(), &Position { x: 1.0, y: 0.0 });
     /// assert_eq!(world.get::<Position>(entities[1]).unwrap(), &Position { x: 0.0, y: 1.0 });