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/Cargo.toml

@@ -11,7 +11,7 @@ categories = ["game-engines", "data-structures"]
 rust-version = "1.83.0"
 
 [features]
-default = ["std", "bevy_reflect", "async_executor"]
+default = ["std", "bevy_reflect", "async_executor", "diagnostic_component_names"]
 
 # Functionality
 
@@ -53,6 +53,11 @@ bevy_debug_stepping = []
 ## This will often provide more detailed error messages.
 track_location = []
 
+## Provides name information in Component traits for use in System conflict diagnostics
+diagnostic_component_names = [
+  "bevy_ecs_macros/diagnostic_component_names"
+]
+
 # Executor Backend
 
 ## Uses `async-executor` as a task execution backend.
@@ -138,6 +143,7 @@ variadics_please = { version = "1.1", default-features = false }
 tracing = { version = "0.1", default-features = false, optional = true }
 log = { version = "0.4", default-features = false }
 bumpalo = "3"
+const_panic = { version = "0.2.12" , features = ["rust_latest_stable"] }
 
 [dev-dependencies]
 rand = "0.8"

crates/bevy_ecs/macros/Cargo.toml

@@ -8,12 +8,16 @@ license = "MIT OR Apache-2.0"
 [lib]
 proc-macro = true
 
+[features]
+diagnostic_component_names = []
+
 [dependencies]
 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,45 +215,94 @@ 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();
+    #[cfg(feature = "diagnostic_component_names")]
+    {
+        let struct_name_2 = struct_name.to_string();
+        // 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;
+                const STRUCT_NAME: Option<&'static str> = Some(#struct_name_2);
+                type Mutability = #mutable_type;
+                fn register_required_components(
+                    requiree: #bevy_ecs_path::component::ComponentId,
+                    components: &mut #bevy_ecs_path::component::Components,
+                    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();
+                }
 
-    // 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;
-            type Mutability = #mutable_type;
-            fn register_required_components(
-                requiree: #bevy_ecs_path::component::ComponentId,
-                components: &mut #bevy_ecs_path::component::Components,
-                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
+                #on_insert
+                #on_replace
+                #on_remove
+                #on_despawn
 
-            #on_add
-            #on_insert
-            #on_replace
-            #on_remove
-            #on_despawn
+                fn clone_behavior() -> #bevy_ecs_path::component::ComponentCloneBehavior {
+                    #clone_behavior
+                }
 
-            fn clone_behavior() -> #bevy_ecs_path::component::ComponentCloneBehavior {
-                #clone_behavior
+                #visit_entities
             }
 
-            #visit_entities
-        }
+            #relationship
 
-        #relationship
+            #relationship_target
+        })
+    }
+    #[cfg(not(feature = "diagnostic_component_names"))]
+    {
+        // 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,
+                    components: &mut #bevy_ecs_path::component::Components,
+                    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();
+                }
 
-        #relationship_target
-    })
+                #on_add
+                #on_insert
+                #on_replace
+                #on_remove
+                #on_despawn
+
+                fn clone_behavior() -> #bevy_ecs_path::component::ComponentCloneBehavior {
+                    #clone_behavior
+                }
+
+                #visit_entities
+            }
+
+            #relationship
+
+            #relationship_target
+        })
+    }
 }
 
 fn visit_entities(data: &Data, bevy_ecs_path: &Path, is_relationship: bool) -> TokenStream2 {

crates/bevy_ecs/src/component.rs

@@ -386,6 +386,18 @@ pub trait Component: Send + Sync + 'static {
     /// A constant indicating the storage type used for this component.
     const STORAGE_TYPE: StorageType;
 
+    /// A randomly generated u128 that is consistent per component type, used to uniquely identify
+    /// components in const contexts.
+    /// This enables compile-time validation of component access patterns
+    /// for both inter-query and intra-query correctness.
+    const UNSTABLE_TYPE_ID: u128;
+
+    /// The name of the component's struct, if available.
+    /// This is used to provide more helpful error messages when component access conflicts
+    /// are detected at compile-time. Will be None if the component isn't derived automatically
+    /// or if the name isn't available.
+    #[cfg(feature = "diagnostic_component_names")]
+    const STRUCT_NAME: Option<&'static str> = None;
     /// 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,
@@ -284,6 +287,19 @@
     /// and is visible to the end user when calling e.g. `Query<Self>::get`.
     type Item<'a>;
 
+    /// A compile-time representation of how this query accesses components.
+    /// Used to validate query compatibility and detect conflicting access patterns
+    /// during const evaluation.
+    /// By default it implements an Ignore, and can be overrided by implementations such as
+    /// impl<T: Component> or impl<T0: QueryData, T1: QueryData>
+    /// There we recursively build up this component access tree, checking for intra-query
+    /// errors along the way.
+    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 +1219,15 @@
 }
 
 /// 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: 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 +1589,15 @@
 }
 
 /// 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: 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 +1736,10 @@
 }
 
 // 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: AccessTreeContainer,
+{
     type ReadOnly = Ref<'__w, T>;
     type Item<'w> = Mut<'w, T>;
 
@@ -1841,6 +1870,9 @@
     type ReadOnly = Option<T::ReadOnly>;
     type Item<'w> = Option<T::Item<'w>>;
 
+    const COMPONENT_ACCESS_TREE_QUERY_DATA: ComponentAccessTree =
+        T::COMPONENT_ACCESS_TREE_QUERY_DATA;
+
     fn shrink<'wlong: 'wshort, 'wshort>(item: Self::Item<'wlong>) -> Self::Item<'wshort> {
         item.map(T::shrink)
     }
@@ -2052,6 +2084,8 @@
             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 +2110,36 @@
         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 {