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,7 +1,10 @@
 use alloc::vec::Vec;
 use bevy_utils::prelude::DebugName;
 
-use super::{IntoSystem, ReadOnlySystem, RunSystemError, System, SystemParamValidationError};
+use super::{
+    IntoSystem, ReadOnlySystem, RunSystemError, System, SystemMeta, SystemMetaProvider,
+    SystemParamValidationError,
+};
 use crate::{
     schedule::InternedSystemSet,
     system::{input::SystemInput, SystemIn},
@@ -216,3 +219,28 @@ where
         run_system(input).map(self)
     }
 }
+
+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, extendable: &mut impl Extend<&'a SystemMeta>) {
+        self.system.extend_with_system_metas(extendable);
+    }
+
+    fn extend_with_system_metas_mut<'a>(
+        &'a mut self,
+        extendable_mut: &mut impl Extend<&'a mut SystemMeta>,
+    ) {
+        self.system.extend_with_system_metas_mut(extendable_mut);
+    }
+}

crates/bevy_ecs/src/system/combinator.rs

@@ -11,7 +11,7 @@ use crate::{
     world::unsafe_world_cell::UnsafeWorldCell,
 };
 
-use super::{IntoSystem, ReadOnlySystem, RunSystemError, System};
+use super::{IntoSystem, ReadOnlySystem, RunSystemError, System, SystemMeta, SystemMetaProvider};
 
 /// Customizes the behavior of a [`CombinatorSystem`].
 ///
@@ -258,6 +258,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`].
 #[derive(Clone)]
 pub struct IntoPipeSystem<A, B> {
@@ -437,6 +468,39 @@ 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, extendable: &mut impl Extend<&'a SystemMeta>) {
+        self.a.extend_with_system_metas(extendable);
+        self.b.extend_with_system_metas(extendable);
+    }
+
+    fn extend_with_system_metas_mut<'a>(
+        &'a mut self,
+        extendable_mut: &mut impl Extend<&'a mut SystemMeta>,
+    ) {
+        self.a.extend_with_system_metas_mut(extendable_mut);
+        self.b.extend_with_system_metas_mut(extendable_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

@@ -12,11 +12,13 @@ use crate::{
 
 use alloc::{borrow::Cow, vec, vec::Vec};
 use bevy_utils::prelude::DebugName;
-use core::marker::PhantomData;
+use core::{iter, marker::PhantomData};
 use variadics_please::all_tuples;
 
 use super::{RunSystemError, SystemParamValidationError, SystemStateFlags};
 
+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
@@ -205,6 +207,35 @@ where
     }
 }
 
+impl<Marker, Out, F> SystemMetaProvider for ExclusiveFunctionSystem<Marker, Out, 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, extendable: &mut impl Extend<&'a SystemMeta>) {
+        extendable.extend(iter::once(&self.system_meta));
+    }
+
+    fn extend_with_system_metas_mut<'a>(
+        &'a mut self,
+        extendable_mut: &mut impl Extend<&'a mut SystemMeta>,
+    ) {
+        extendable_mut.extend(iter::once(&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

@@ -14,7 +14,7 @@ use crate::{
 
 use alloc::{borrow::Cow, vec, vec::Vec};
 use bevy_utils::prelude::DebugName;
-use core::marker::PhantomData;
+use core::{iter, marker::PhantomData};
 use variadics_please::all_tuples;
 
 #[cfg(feature = "trace")]
@@ -39,6 +39,24 @@ 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, extendable: &mut impl Extend<&'a SystemMeta>);
+
+    /// Helper method for `system_metas_mut`.
+    fn extend_with_system_metas_mut<'a>(
+        &'a mut self,
+        extendable_mut: &mut impl Extend<&'a mut SystemMeta>,
+    );
+}
+
 impl SystemMeta {
     pub(crate) fn new<T>() -> Self {
         let name = DebugName::type_name::<T>();
@@ -807,6 +825,35 @@ where
 {
 }
 
+impl<Marker, Out, F> SystemMetaProvider for FunctionSystem<Marker, Out, 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, extendable: &mut impl Extend<&'a SystemMeta>) {
+        extendable.extend(iter::once(&self.system_meta));
+    }
+
+    fn extend_with_system_metas_mut<'a>(
+        &'a mut self,
+        extendable_mut: &mut impl Extend<&'a mut SystemMeta>,
+    ) {
+        extendable_mut.extend(iter::once(&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,