Implement System::system_metas(&self) and System::system_metas_mut(&mut self)

for system exploration and configuration

Part of #16168

Author: Rajveer100

crates/bevy_ecs/src/system/adapter_system.rs

@@ -1,6 +1,6 @@
 use alloc::borrow::Cow;
 
-use super::{IntoSystem, ReadOnlySystem, System};
+use super::{IntoSystem, ReadOnlySystem, System, SystemMeta, SystemMetaProvider};
 use crate::{
     schedule::InternedSystemSet,
     system::{input::SystemInput, SystemIn},
@@ -234,3 +234,25 @@ where
         self(run_system(input))
     }
 }
+
+impl<Func, S> SystemMetaProvider for AdapterSystem<Func, S>
+where
+    Func: Adapt<S>,
+    S: System + SystemMetaProvider,
+{
+    fn system_metas(&self) -> Vec<&SystemMeta> {
+        self.system.system_metas()
+    }
+
+    fn system_metas_mut(&mut self) -> Vec<&mut SystemMeta> {
+        self.system.system_metas_mut()
+    }
+
+    fn extend_with_system_metas<'a>(&'a self, vec: &mut Vec<&'a SystemMeta>) {
+        self.system.extend_with_system_metas(vec);
+    }
+
+    fn extend_with_system_metas_mut<'a>(&'a mut self, vec_mut: &mut Vec<&'a mut SystemMeta>) {
+        self.system.extend_with_system_metas_mut(vec_mut);
+    }
+}

crates/bevy_ecs/src/system/combinator.rs

@@ -11,7 +11,7 @@ use crate::{
     world::unsafe_world_cell::UnsafeWorldCell,
 };
 
-use super::{IntoSystem, ReadOnlySystem, System};
+use super::{IntoSystem, ReadOnlySystem, System, SystemMeta, SystemMetaProvider};
 
 /// Customizes the behavior of a [`CombinatorSystem`].
 ///
@@ -275,6 +275,37 @@ where
     }
 }
 
+impl<Func, A, B> SystemMetaProvider for CombinatorSystem<Func, A, B>
+where
+    Func: Combine<A, B> + 'static,
+    A: System + SystemMetaProvider,
+    B: System + SystemMetaProvider,
+{
+    fn system_metas(&self) -> Vec<&SystemMeta> {
+        let mut vec: Vec<&SystemMeta> = Vec::new();
+        self.a.extend_with_system_metas(&mut vec);
+        self.b.extend_with_system_metas(&mut vec);
+        vec
+    }
+
+    fn system_metas_mut(&mut self) -> Vec<&mut SystemMeta> {
+        let mut vec_mut: Vec<&mut SystemMeta> = Vec::new();
+        self.a.extend_with_system_metas_mut(&mut vec_mut);
+        self.b.extend_with_system_metas_mut(&mut vec_mut);
+        vec_mut
+    }
+
+    fn extend_with_system_metas<'a>(&'a self, vec: &mut Vec<&'a SystemMeta>) {
+        self.a.extend_with_system_metas(vec);
+        self.b.extend_with_system_metas(vec);
+    }
+
+    fn extend_with_system_metas_mut<'a>(&'a mut self, vec_mut: &mut Vec<&'a mut SystemMeta>) {
+        self.a.extend_with_system_metas_mut(vec_mut);
+        self.b.extend_with_system_metas_mut(vec_mut);
+    }
+}
+
 /// An [`IntoSystem`] creating an instance of [`PipeSystem`].
 pub struct IntoPipeSystem<A, B> {
     a: A,
@@ -478,6 +509,36 @@ where
     }
 }
 
+impl<A, B> SystemMetaProvider for PipeSystem<A, B>
+where
+    A: System + SystemMetaProvider,
+    B: System + SystemMetaProvider,
+{
+    fn system_metas(&self) -> Vec<&SystemMeta> {
+        let mut vec: Vec<&SystemMeta> = Vec::new();
+        self.a.extend_with_system_metas(&mut vec);
+        self.b.extend_with_system_metas(&mut vec);
+        vec
+    }
+
+    fn system_metas_mut(&mut self) -> Vec<&mut SystemMeta> {
+        let mut vec_mut: Vec<&mut SystemMeta> = Vec::new();
+        self.a.extend_with_system_metas_mut(&mut vec_mut);
+        self.b.extend_with_system_metas_mut(&mut vec_mut);
+        vec_mut
+    }
+
+    fn extend_with_system_metas<'a>(&'a self, vec: &mut Vec<&'a SystemMeta>) {
+        self.a.extend_with_system_metas(vec);
+        self.b.extend_with_system_metas(vec);
+    }
+
+    fn extend_with_system_metas_mut<'a>(&'a mut self, vec_mut: &mut Vec<&'a mut SystemMeta>) {
+        self.a.extend_with_system_metas_mut(vec_mut);
+        self.b.extend_with_system_metas_mut(vec_mut);
+    }
+}
+
 /// SAFETY: Both systems are read-only, so any system created by piping them will only read from the world.
 unsafe impl<A, B> ReadOnlySystem for PipeSystem<A, B>
 where

crates/bevy_ecs/src/system/exclusive_function_system.rs

@@ -14,6 +14,8 @@ use alloc::borrow::Cow;
 use bevy_utils::all_tuples;
 use core::marker::PhantomData;
 
+use super::SystemMetaProvider;
+
 /// A function system that runs with exclusive [`World`] access.
 ///
 /// You get this by calling [`IntoSystem::into_system`]  on a function that only accepts
@@ -186,6 +188,32 @@ where
     }
 }
 
+impl<Marker, F> SystemMetaProvider for ExclusiveFunctionSystem<Marker, F>
+where
+    Marker: 'static,
+    F: ExclusiveSystemParamFunction<Marker>,
+{
+    fn system_metas(&self) -> Vec<&SystemMeta> {
+        let mut vec: Vec<&SystemMeta> = Vec::new();
+        self.extend_with_system_metas(&mut vec);
+        vec
+    }
+
+    fn system_metas_mut(&mut self) -> Vec<&mut SystemMeta> {
+        let mut vec: Vec<&mut SystemMeta> = Vec::new();
+        self.extend_with_system_metas_mut(&mut vec);
+        vec
+    }
+
+    fn extend_with_system_metas<'a>(&'a self, vec: &mut Vec<&'a SystemMeta>) {
+        vec.push(&self.system_meta);
+    }
+
+    fn extend_with_system_metas_mut<'a>(&'a mut self, vec_mut: &mut Vec<&'a mut SystemMeta>) {
+        vec_mut.push(&mut self.system_meta);
+    }
+}
+
 /// A trait implemented for all exclusive system functions that can be used as [`System`]s.
 ///
 /// This trait can be useful for making your own systems which accept other systems,

crates/bevy_ecs/src/system/function_system.rs

@@ -50,6 +50,21 @@ pub struct SystemMeta {
     pub(crate) commands_span: Span,
 }
 
+/// Trait for retrieving system metas.
+pub trait SystemMetaProvider {
+    /// Returns immutable references of system metas as a vector.
+    fn system_metas(&self) -> Vec<&SystemMeta>;
+
+    /// Returns mutable references of system metas as a vector.
+    fn system_metas_mut(&mut self) -> Vec<&mut SystemMeta>;
+
+    /// Helper method for `system_metas`.
+    fn extend_with_system_metas<'a>(&'a self, vec: &mut Vec<&'a SystemMeta>);
+
+    /// Helper method for `system_metas_mut`.
+    fn extend_with_system_metas_mut<'a>(&'a mut self, vec_mut: &mut Vec<&'a mut SystemMeta>);
+}
+
 impl SystemMeta {
     pub(crate) fn new<T>() -> Self {
         let name = core::any::type_name::<T>();
@@ -826,6 +841,32 @@ where
 {
 }
 
+impl<Marker, F> SystemMetaProvider for FunctionSystem<Marker, F>
+where
+    Marker: 'static,
+    F: SystemParamFunction<Marker>,
+{
+    fn system_metas(&self) -> Vec<&SystemMeta> {
+        let mut vec: Vec<&SystemMeta> = Vec::new();
+        self.extend_with_system_metas(&mut vec);
+        vec
+    }
+
+    fn system_metas_mut(&mut self) -> Vec<&mut SystemMeta> {
+        let mut vec: Vec<&mut SystemMeta> = Vec::new();
+        self.extend_with_system_metas_mut(&mut vec);
+        vec
+    }
+
+    fn extend_with_system_metas<'a>(&'a self, vec: &mut Vec<&'a SystemMeta>) {
+        vec.push(&self.system_meta);
+    }
+
+    fn extend_with_system_metas_mut<'a>(&'a mut self, vec_mut: &mut Vec<&'a mut SystemMeta>) {
+        vec_mut.push(&mut self.system_meta);
+    }
+}
+
 /// A trait implemented for all functions that can be used as [`System`]s.
 ///
 /// This trait can be useful for making your own systems which accept other systems,