Move recursion_check_stack parameter into ComponentsRegistrator

Author: SkiFire13

crates/bevy_ecs/macros/src/component.rs

@@ -246,8 +246,7 @@ pub fn derive_component(input: TokenStream) -> TokenStream {
                     requiree,
                     components,
                     required_components,
-                    inheritance_depth + 1,
-                    recursion_check_stack
+                    inheritance_depth + 1
                 );
             });
             match &require.func {
@@ -256,8 +255,7 @@ pub fn derive_component(input: TokenStream) -> TokenStream {
                         components.register_required_components_manual::<Self, #ident>(
                             required_components,
                             || { let x: #ident = (#func)().into(); x },
-                            inheritance_depth,
-                            recursion_check_stack
+                            inheritance_depth
                         );
                     });
                 }
@@ -266,8 +264,7 @@ pub fn derive_component(input: TokenStream) -> TokenStream {
                         components.register_required_components_manual::<Self, #ident>(
                             required_components,
                             <#ident as Default>::default,
-                            inheritance_depth,
-                            recursion_check_stack
+                            inheritance_depth
                         );
                     });
                 }
@@ -312,18 +309,13 @@ pub fn derive_component(input: TokenStream) -> TokenStream {
             const STORAGE_TYPE: #bevy_ecs_path::component::StorageType = #storage;
             type Mutability = #mutable_type;
             fn register_required_components(
-                requiree: #bevy_ecs_path::component::ComponentId,
+                _requiree: #bevy_ecs_path::component::ComponentId,
                 components: &mut #bevy_ecs_path::component::ComponentsRegistrator,
                 required_components: &mut #bevy_ecs_path::component::RequiredComponents,
                 inheritance_depth: u16,
-                recursion_check_stack: &mut #bevy_ecs_path::__macro_exports::Vec<#bevy_ecs_path::component::ComponentId>
             ) {
-                #bevy_ecs_path::component::enforce_no_required_components_recursion(components, recursion_check_stack);
-                let self_id = components.register_component::<Self>();
-                recursion_check_stack.push(self_id);
                 #(#register_required)*
                 #(#register_recursive_requires)*
-                recursion_check_stack.pop();
             }
 
             #on_add

crates/bevy_ecs/src/component/mod.rs

@@ -18,7 +18,6 @@ use crate::{
     system::{Local, SystemParam},
     world::{FromWorld, World},
 };
-use alloc::vec::Vec;
 pub use bevy_ecs_macros::Component;
 use core::{fmt::Debug, marker::PhantomData, ops::Deref};
 
@@ -528,7 +527,6 @@ pub trait Component: Send + Sync + 'static {
         _components: &mut ComponentsRegistrator,
         _required_components: &mut RequiredComponents,
         _inheritance_depth: u16,
-        _recursion_check_stack: &mut Vec<ComponentId>,
     ) {
     }
 

crates/bevy_ecs/src/component/register.rs

@@ -64,6 +64,7 @@ impl ComponentIds {
 pub struct ComponentsRegistrator<'w> {
     components: &'w mut Components,
     ids: &'w mut ComponentIds,
+    pub(super) recursion_check_stack: Vec<ComponentId>,
 }
 
 impl Deref for ComponentsRegistrator<'_> {
@@ -88,7 +89,11 @@ impl<'w> ComponentsRegistrator<'w> {
     /// The [`Components`] and [`ComponentIds`] must match.
     /// For example, they must be from the same world.
     pub unsafe fn new(components: &'w mut Components, ids: &'w mut ComponentIds) -> Self {
-        Self { components, ids }
+        Self {
+            components,
+            ids,
+            recursion_check_stack: Vec::new(),
+        }
     }
 
     /// Converts this [`ComponentsRegistrator`] into a [`ComponentsQueuedRegistrator`].
@@ -177,15 +182,12 @@ impl<'w> ComponentsRegistrator<'w> {
     /// * [`ComponentsRegistrator::register_component_with_descriptor()`]
     #[inline]
     pub fn register_component<T: Component>(&mut self) -> ComponentId {
-        self.register_component_checked::<T>(&mut Vec::new())
+        self.register_component_checked::<T>()
     }
 
     /// Same as [`Self::register_component_unchecked`] but keeps a checks for safety.
     #[inline]
-    pub(super) fn register_component_checked<T: Component>(
-        &mut self,
-        recursion_check_stack: &mut Vec<ComponentId>,
-    ) -> ComponentId {
+    pub(super) fn register_component_checked<T: Component>(&mut self) -> ComponentId {
         let type_id = TypeId::of::<T>();
         if let Some(id) = self.indices.get(&type_id) {
             return *id;
@@ -207,7 +209,7 @@ impl<'w> ComponentsRegistrator<'w> {
         let id = self.ids.next_mut();
         // SAFETY: The component is not currently registered, and the id is fresh.
         unsafe {
-            self.register_component_unchecked::<T>(recursion_check_stack, id);
+            self.register_component_unchecked::<T>(id);
         }
         id
     }
@@ -216,11 +218,7 @@ impl<'w> ComponentsRegistrator<'w> {
     ///
     /// Neither this component, nor its id may be registered or queued. This must be a new registration.
     #[inline]
-    unsafe fn register_component_unchecked<T: Component>(
-        &mut self,
-        recursion_check_stack: &mut Vec<ComponentId>,
-        id: ComponentId,
-    ) {
+    unsafe fn register_component_unchecked<T: Component>(&mut self, id: ComponentId) {
         // SAFETY: ensured by caller.
         unsafe {
             self.register_component_inner(id, ComponentDescriptor::new::<T>());
@@ -229,14 +227,10 @@ impl<'w> ComponentsRegistrator<'w> {
         let prev = self.indices.insert(type_id, id);
         debug_assert!(prev.is_none());
 
+        self.recursion_check_stack.push(id);
         let mut required_components = RequiredComponents::default();
-        T::register_required_components(
-            id,
-            self,
-            &mut required_components,
-            0,
-            recursion_check_stack,
-        );
+        T::register_required_components(id, self, &mut required_components, 0);
+        self.recursion_check_stack.pop();
         // SAFETY: we just inserted it in `register_component_inner`
         let info = unsafe {
             &mut self
@@ -563,7 +557,7 @@ impl<'w> ComponentsQueuedRegistrator<'w> {
                         // SAFETY: We just checked that this is not currently registered or queued, and if it was registered since, this would have been dropped from the queue.
                         #[expect(unused_unsafe, reason = "More precise to specify.")]
                         unsafe {
-                            registrator.register_component_unchecked::<T>(&mut Vec::new(), id);
+                            registrator.register_component_unchecked::<T>(id);
                         }
                     },
                 )

crates/bevy_ecs/src/component/required.rs

@@ -231,9 +231,6 @@ impl<'w> ComponentsRegistrator<'w> {
     /// A direct requirement has a depth of `0`, and each level of inheritance increases the depth by `1`.
     /// Lower depths are more specific requirements, and can override existing less specific registrations.
     ///
-    /// The `recursion_check_stack` allows checking whether this component tried to register itself as its
-    /// own (indirect) required component.
-    ///
     /// This method does *not* register any components as required by components that require `T`.
     ///
     /// Only use this method if you know what you are doing. In most cases, you should instead use [`World::register_required_components`],
@@ -246,10 +243,11 @@ impl<'w> ComponentsRegistrator<'w> {
         required_components: &mut RequiredComponents,
         constructor: fn() -> R,
         inheritance_depth: u16,
-        recursion_check_stack: &mut Vec<ComponentId>,
     ) {
-        let requiree = self.register_component_checked::<T>(recursion_check_stack);
-        let required = self.register_component_checked::<R>(recursion_check_stack);
+        let requiree = self.register_component_checked::<T>();
+        let required = self.register_component_checked::<R>();
+
+        enforce_no_required_components_recursion(self, &self.recursion_check_stack, required);
 
         // SAFETY: We just created the components.
         unsafe {
@@ -501,36 +499,31 @@ impl RequiredComponents {
     }
 }
 
-// NOTE: This should maybe be private, but it is currently public so that `bevy_ecs_macros` can use it.
-// This exists as a standalone function instead of being inlined into the component derive macro so as
-// to reduce the amount of generated code.
-#[doc(hidden)]
-pub fn enforce_no_required_components_recursion(
+fn enforce_no_required_components_recursion(
     components: &Components,
     recursion_check_stack: &[ComponentId],
+    required: ComponentId,
 ) {
-    if let Some((&requiree, check)) = recursion_check_stack.split_last() {
-        if let Some(direct_recursion) = check
-            .iter()
-            .position(|&id| id == requiree)
-            .map(|index| index == check.len() - 1)
-        {
-            panic!(
-                "Recursive required components detected: {}\nhelp: {}",
-                recursion_check_stack
-                    .iter()
-                    .map(|id| format!("{}", components.get_name(*id).unwrap().shortname()))
-                    .collect::<Vec<_>>()
-                    .join(" → "),
-                if direct_recursion {
-                    format!(
-                        "Remove require({}).",
-                        components.get_name(requiree).unwrap().shortname()
-                    )
-                } else {
-                    "If this is intentional, consider merging the components.".into()
-                }
-            );
-        }
+    if let Some(direct_recursion) = recursion_check_stack
+        .iter()
+        .position(|&id| id == required)
+        .map(|index| index == recursion_check_stack.len() - 1)
+    {
+        panic!(
+            "Recursive required components detected: {}\nhelp: {}",
+            recursion_check_stack
+                .iter()
+                .map(|id| format!("{}", components.get_name(*id).unwrap().shortname()))
+                .collect::<Vec<_>>()
+                .join(" → "),
+            if direct_recursion {
+                format!(
+                    "Remove require({}).",
+                    components.get_name(required).unwrap().shortname()
+                )
+            } else {
+                "If this is intentional, consider merging the components.".into()
+            }
+        );
     }
 }