Compile Time Query checking and System Parameters

crates/bevy_core_pipeline/src/oit/mod.rs

@@ -68,6 +68,7 @@ impl Default for OrderIndependentTransparencySettings {
 // we can hook on_add to issue a warning in case `layer_count` is seemingly too high.
 impl Component for OrderIndependentTransparencySettings {
     const STORAGE_TYPE: StorageType = StorageType::SparseSet;
+    const UNSTABLE_TYPE_ID: u128 = 28539417283523;
     type Mutability = Mutable;
 
     fn on_add() -> Option<ComponentHook> {

crates/bevy_ecs/examples/change_detection.rs

@@ -29,6 +29,8 @@ fn main() {
     // We can label our systems to force a specific run-order between some of them
     schedule.add_systems((
         spawn_entities.in_set(SimulationSet::Spawn),
+        test,
+        test2.before(test),
         print_counter_when_changed.after(SimulationSet::Spawn),
         age_all_entities.in_set(SimulationSet::Age),
         remove_old_entities.after(SimulationSet::Age),
@@ -90,6 +92,19 @@ fn print_changed_entities(
     }
 }
 
+#[derive(Component)]
+pub struct Awa;
+
+fn test(query1: Query<&mut Age, With<Awa>>, query2: Query<&mut Age, Without<Awa>>) {
+
+}
+
+
+fn test2(query1: Query<&mut Age, With<Awa>>, query2: Query<&mut Age, Without<Awa>>) {
+
+}
+
+
 // This system iterates over all entities and increases their age in every frame
 fn age_all_entities(mut entities: Query<&mut Age>) {
     for mut age in &mut entities {

crates/bevy_ecs/macros/Cargo.toml

@@ -14,6 +14,7 @@ bevy_macro_utils = { path = "../../bevy_macro_utils", version = "0.16.0-dev" }
 syn = { version = "2.0", features = ["full"] }
 quote = "1.0"
 proc-macro2 = "1.0"
+rand = "0.9.0"
 [lints]
 workspace = true
 

crates/bevy_ecs/macros/src/component.rs

@@ -1,6 +1,7 @@
 use proc_macro::{TokenStream, TokenTree};
 use proc_macro2::{Span, TokenStream as TokenStream2};
 use quote::{format_ident, quote, ToTokens};
+use rand::Rng;
 use std::collections::HashSet;
 use syn::{
     parenthesized,
@@ -214,12 +215,14 @@ pub fn derive_component(input: TokenStream) -> TokenStream {
             (&&&#bevy_ecs_path::component::DefaultCloneBehaviorSpecialization::<Self>::default()).default_clone_behavior()
         )
     };
-
+    let mut rng = rand::rng();
+    let unstable_type_id: u128 = rng.random();
     // This puts `register_required` before `register_recursive_requires` to ensure that the constructors of _all_ top
     // level components are initialized first, giving them precedence over recursively defined constructors for the same component type
     TokenStream::from(quote! {
         impl #impl_generics #bevy_ecs_path::component::Component for #struct_name #type_generics #where_clause {
             const STORAGE_TYPE: #bevy_ecs_path::component::StorageType = #storage;
+            const UNSTABLE_TYPE_ID: u128 = #unstable_type_id;
             type Mutability = #mutable_type;
             fn register_required_components(
                 requiree: #bevy_ecs_path::component::ComponentId,

crates/bevy_ecs/src/component.rs

@@ -386,6 +386,8 @@ pub trait Component: Send + Sync + 'static {
     /// A constant indicating the storage type used for this component.
     const STORAGE_TYPE: StorageType;
 
+    /// A u128 randomly generated that is consistent per component type or 0 if it isn't derived automatically and can be used to differentiate them in const contexts.
+    const UNSTABLE_TYPE_ID: u128;
     /// A marker type to assist Bevy with determining if this component is
     /// mutable, or immutable. Mutable components will have [`Component<Mutability = Mutable>`],
     /// while immutable components will instead have [`Component<Mutability = Immutable>`].

crates/bevy_ecs/src/observer/entity_observer.rs

@@ -15,6 +15,7 @@ pub struct ObservedBy(pub(crate) Vec<Entity>);
 
 impl Component for ObservedBy {
     const STORAGE_TYPE: StorageType = StorageType::SparseSet;
+    const UNSTABLE_TYPE_ID: u128 = 1;
     type Mutability = Mutable;
 
     fn on_remove() -> Option<ComponentHook> {

crates/bevy_ecs/src/observer/runner.rs

@@ -64,6 +64,7 @@ impl ObserverState {
 
 impl Component for ObserverState {
     const STORAGE_TYPE: StorageType = StorageType::SparseSet;
+    const UNSTABLE_TYPE_ID: u128 = 2;
     type Mutability = Mutable;
 
     fn on_add() -> Option<ComponentHook> {
@@ -335,6 +336,7 @@ impl Observer {
 
 impl Component for Observer {
     const STORAGE_TYPE: StorageType = StorageType::SparseSet;
+    const UNSTABLE_TYPE_ID: u128 = 3;
     type Mutability = Mutable;
     fn on_add() -> Option<ComponentHook> {
         Some(|world, context| {

crates/bevy_ecs/src/query/fetch.rs

@@ -1,3 +1,6 @@
+use crate::system::const_param_checking::{
+    AccessTreeContainer, ComponentAccess, ComponentAccessTree,
+};
 use crate::{
     archetype::{Archetype, Archetypes},
     bundle::Bundle,
@@ -11,6 +14,7 @@ use crate::{
         FilteredEntityMut, FilteredEntityRef, Mut, Ref, World,
     },
 };
+use bevy_ecs::system::const_param_checking::{WithFilterTree, WithoutFilterTree};
 use bevy_ptr::{ThinSlicePtr, UnsafeCellDeref};
 use core::{cell::UnsafeCell, marker::PhantomData, panic::Location};
 use smallvec::SmallVec;
@@ -284,6 +288,12 @@ pub unsafe trait QueryData: WorldQuery {
     /// and is visible to the end user when calling e.g. `Query<Self>::get`.
     type Item<'a>;
 
+    const COMPONENT_ACCESS_TREE_QUERY_DATA: ComponentAccessTree = ComponentAccessTree {
+        this: ComponentAccess::Ignore,
+        left: None,
+        right: None,
+    };
+
     /// This function manually implements subtyping for the query items.
     fn shrink<'wlong: 'wshort, 'wshort>(item: Self::Item<'wlong>) -> Self::Item<'wshort>;
 
@@ -1203,10 +1213,15 @@ unsafe impl<T: Component> WorldQuery for &T {
 }
 
 /// SAFETY: `Self` is the same as `Self::ReadOnly`
-unsafe impl<T: Component> QueryData for &T {
+unsafe impl<T: Component> QueryData for &T
+where
+    for<'a> &'a T: crate::system::const_param_checking::AccessTreeContainer,
+{
     type ReadOnly = Self;
     type Item<'w> = &'w T;
 
+    const COMPONENT_ACCESS_TREE_QUERY_DATA: ComponentAccessTree = Self::COMPONENT_ACCESS_TREE;
+
     fn shrink<'wlong: 'wshort, 'wshort>(item: &'wlong T) -> &'wshort T {
         item
     }
@@ -1568,10 +1583,15 @@ unsafe impl<'__w, T: Component> WorldQuery for &'__w mut T {
 }
 
 /// SAFETY: access of `&T` is a subset of `&mut T`
-unsafe impl<'__w, T: Component<Mutability = Mutable>> QueryData for &'__w mut T {
+unsafe impl<'__w, T: Component<Mutability = Mutable>> QueryData for &'__w mut T
+where
+    for<'a> &'a mut T: crate::system::const_param_checking::AccessTreeContainer,
+{
     type ReadOnly = &'__w T;
     type Item<'w> = Mut<'w, T>;
 
+    const COMPONENT_ACCESS_TREE_QUERY_DATA: ComponentAccessTree = Self::COMPONENT_ACCESS_TREE;
+
     fn shrink<'wlong: 'wshort, 'wshort>(item: Mut<'wlong, T>) -> Mut<'wshort, T> {
         item
     }
@@ -1710,7 +1730,10 @@ unsafe impl<'__w, T: Component> WorldQuery for Mut<'__w, T> {
 }
 
 // SAFETY: access of `Ref<T>` is a subset of `Mut<T>`
-unsafe impl<'__w, T: Component<Mutability = Mutable>> QueryData for Mut<'__w, T> {
+unsafe impl<'__w, T: Component<Mutability = Mutable>> QueryData for Mut<'__w, T>
+where
+    for<'a> &'a mut T: crate::system::const_param_checking::AccessTreeContainer,
+{
     type ReadOnly = Ref<'__w, T>;
     type Item<'w> = Mut<'w, T>;
 
@@ -2052,6 +2075,8 @@ macro_rules! impl_tuple_query_data {
             type ReadOnly = ($($name::ReadOnly,)*);
             type Item<'w> = ($($name::Item<'w>,)*);
 
+            const COMPONENT_ACCESS_TREE_QUERY_DATA: ComponentAccessTree = impl_tuple_query_data!(@tree $($name),*);
+
             fn shrink<'wlong: 'wshort, 'wshort>(item: Self::Item<'wlong>) -> Self::Item<'wshort> {
                 let ($($name,)*) = item;
                 ($(
@@ -2076,6 +2101,36 @@ macro_rules! impl_tuple_query_data {
         unsafe impl<$($name: ReadOnlyQueryData),*> ReadOnlyQueryData for ($($name,)*) {}
 
     };
+
+    // Handle empty case
+    (@tree) => {
+        ComponentAccessTree {
+            this: ComponentAccess::Ignore,
+            left: None,
+            right: None,
+        }
+    };
+    // Handle single item case
+    (@tree $t0:ident) => {
+        $t0::COMPONENT_ACCESS_TREE_QUERY_DATA
+    };
+    // Handle two item case
+    (@tree $t0:ident, $t1:ident) => {
+        ComponentAccessTree::combine(
+            &$t0::COMPONENT_ACCESS_TREE_QUERY_DATA,
+            &$t1::COMPONENT_ACCESS_TREE_QUERY_DATA,
+        )
+    };
+    // Handle three or more items case
+    (@tree $t0:ident, $t1:ident, $($rest:ident),+) => {
+        ComponentAccessTree::combine(
+            &$t0::COMPONENT_ACCESS_TREE_QUERY_DATA,
+            &ComponentAccessTree::combine(
+                &$t1::COMPONENT_ACCESS_TREE_QUERY_DATA,
+                &impl_tuple_query_data!(@tree $($rest),+)
+            )
+        )
+    };
 }
 
 macro_rules! impl_anytuple_fetch {

crates/bevy_ecs/src/query/filter.rs

@@ -1,3 +1,4 @@
+use crate::system::const_param_checking::{WithId, WithoutId};
 use crate::{
     archetype::Archetype,
     component::{Component, ComponentId, Components, StorageType, Tick},
@@ -6,6 +7,7 @@ use crate::{
     storage::{ComponentSparseSet, Table, TableRow},
     world::{unsafe_world_cell::UnsafeWorldCell, World},
 };
+use bevy_ecs::system::const_param_checking::{WithFilterTree, WithoutFilterTree};
 use bevy_ptr::{ThinSlicePtr, UnsafeCellDeref};
 use core::{cell::UnsafeCell, marker::PhantomData};
 use variadics_please::all_tuples;
@@ -89,6 +91,9 @@ pub unsafe trait QueryFilter: WorldQuery {
     /// If this is `true`, then [`QueryFilter::filter_fetch`] must always return true.
     const IS_ARCHETYPAL: bool;
 
+    const WITH_FILTER_TREE_QUERY_DATA: Option<WithFilterTree> = None;
+    const WITHOUT_FILTER_TREE_QUERY_DATA: Option<WithoutFilterTree> = None;
+
     /// Returns true if the provided [`Entity`] and [`TableRow`] should be included in the query results.
     /// If false, the entity will be skipped.
     ///
@@ -202,6 +207,12 @@ unsafe impl<T: Component> WorldQuery for With<T> {
 unsafe impl<T: Component> QueryFilter for With<T> {
     const IS_ARCHETYPAL: bool = true;
 
+    const WITH_FILTER_TREE_QUERY_DATA: Option<WithFilterTree> = Some(WithFilterTree {
+        this: WithId(T::UNSTABLE_TYPE_ID),
+        left: None,
+        right: None,
+    });
+
     #[inline(always)]
     unsafe fn filter_fetch(
         _fetch: &mut Self::Fetch<'_>,
@@ -302,6 +313,12 @@ unsafe impl<T: Component> WorldQuery for Without<T> {
 unsafe impl<T: Component> QueryFilter for Without<T> {
     const IS_ARCHETYPAL: bool = true;
 
+    const WITHOUT_FILTER_TREE_QUERY_DATA: Option<WithoutFilterTree> = Some(WithoutFilterTree {
+        this: WithoutId(T::UNSTABLE_TYPE_ID),
+        left: None,
+        right: None,
+    });
+
     #[inline(always)]
     unsafe fn filter_fetch(
         _fetch: &mut Self::Fetch<'_>,
@@ -748,6 +765,13 @@ unsafe impl<T: Component> WorldQuery for Added<T> {
 // SAFETY: WorldQuery impl performs only read access on ticks
 unsafe impl<T: Component> QueryFilter for Added<T> {
     const IS_ARCHETYPAL: bool = false;
+
+    const WITH_FILTER_TREE_QUERY_DATA: Option<WithFilterTree> = Some(WithFilterTree {
+        this: WithId(T::UNSTABLE_TYPE_ID),
+        left: None,
+        right: None,
+    });
+
     #[inline(always)]
     unsafe fn filter_fetch(
         fetch: &mut Self::Fetch<'_>,
@@ -975,7 +999,11 @@ unsafe impl<T: Component> WorldQuery for Changed<T> {
 // SAFETY: WorldQuery impl performs only read access on ticks
 unsafe impl<T: Component> QueryFilter for Changed<T> {
     const IS_ARCHETYPAL: bool = false;
-
+    const WITH_FILTER_TREE_QUERY_DATA: Option<WithFilterTree> = Some(WithFilterTree {
+        this: WithId(T::UNSTABLE_TYPE_ID),
+        left: None,
+        right: None,
+    });
     #[inline(always)]
     unsafe fn filter_fetch(
         fetch: &mut Self::Fetch<'_>,