Make WorldQuery use &World for initialization

benches/benches/bevy_ecs/world/world_get.rs

@@ -106,7 +106,7 @@ pub fn world_query_get(criterion: &mut Criterion) {
 
     for entity_count in RANGE.map(|i| i * 10_000) {
         group.bench_function(format!("{entity_count}_entities_table"), |bencher| {
-            let (mut world, entities) = setup::<Table>(entity_count);
+            let (world, entities) = setup::<Table>(entity_count);
             let mut query = world.query::<&Table>();
 
             bencher.iter(|| {
@@ -116,7 +116,7 @@ pub fn world_query_get(criterion: &mut Criterion) {
             });
         });
         group.bench_function(format!("{entity_count}_entities_table_wide"), |bencher| {
-            let (mut world, entities) = setup_wide::<(
+            let (world, entities) = setup_wide::<(
                 WideTable<0>,
                 WideTable<1>,
                 WideTable<2>,
@@ -140,7 +140,7 @@ pub fn world_query_get(criterion: &mut Criterion) {
             });
         });
         group.bench_function(format!("{entity_count}_entities_sparse"), |bencher| {
-            let (mut world, entities) = setup::<Sparse>(entity_count);
+            let (world, entities) = setup::<Sparse>(entity_count);
             let mut query = world.query::<&Sparse>();
 
             bencher.iter(|| {
@@ -150,7 +150,7 @@ pub fn world_query_get(criterion: &mut Criterion) {
             });
         });
         group.bench_function(format!("{entity_count}_entities_sparse_wide"), |bencher| {
-            let (mut world, entities) = setup_wide::<(
+            let (world, entities) = setup_wide::<(
                 WideSparse<0>,
                 WideSparse<1>,
                 WideSparse<2>,
@@ -185,7 +185,7 @@ pub fn world_query_iter(criterion: &mut Criterion) {
 
     for entity_count in RANGE.map(|i| i * 10_000) {
         group.bench_function(format!("{entity_count}_entities_table"), |bencher| {
-            let (mut world, _) = setup::<Table>(entity_count);
+            let (world, _) = setup::<Table>(entity_count);
             let mut query = world.query::<&Table>();
 
             bencher.iter(|| {
@@ -199,7 +199,7 @@ pub fn world_query_iter(criterion: &mut Criterion) {
             });
         });
         group.bench_function(format!("{entity_count}_entities_sparse"), |bencher| {
-            let (mut world, _) = setup::<Sparse>(entity_count);
+            let (world, _) = setup::<Sparse>(entity_count);
             let mut query = world.query::<&Sparse>();
 
             bencher.iter(|| {
@@ -224,7 +224,7 @@ pub fn world_query_for_each(criterion: &mut Criterion) {
 
     for entity_count in RANGE.map(|i| i * 10_000) {
         group.bench_function(format!("{entity_count}_entities_table"), |bencher| {
-            let (mut world, _) = setup::<Table>(entity_count);
+            let (world, _) = setup::<Table>(entity_count);
             let mut query = world.query::<&Table>();
 
             bencher.iter(|| {
@@ -238,7 +238,7 @@ pub fn world_query_for_each(criterion: &mut Criterion) {
             });
         });
         group.bench_function(format!("{entity_count}_entities_sparse"), |bencher| {
-            let (mut world, _) = setup::<Sparse>(entity_count);
+            let (world, _) = setup::<Sparse>(entity_count);
             let mut query = world.query::<&Sparse>();
 
             bencher.iter(|| {

crates/bevy_asset/src/asset_changed.rs

@@ -105,6 +105,7 @@ impl<'w, A: AsAssetId> AssetChangeCheck<'w, A> {
 ///
 /// - Asset changes are registered in the [`AssetEventSystems`] system set.
 /// - Removed assets are not detected.
+/// - The asset must be initialized ([`App::init_asset`](crate::AssetApp::init_asset)).
 ///
 /// The list of changed assets only gets updated in the [`AssetEventSystems`] system set,
 /// which runs in `PostUpdate`. Therefore, `AssetChanged` will only pick up asset changes in schedules
@@ -235,9 +236,10 @@ unsafe impl<A: AsAssetId> WorldQuery for AssetChanged<A> {
         access.add_resource_read(state.resource_id);
     }
 
-    fn init_state(world: &mut World) -> AssetChangedState<A> {
-        let resource_id = world.init_resource::<AssetChanges<A::Asset>>();
-        let asset_id = world.register_component::<A>();
+    fn init_state(world: &World) -> AssetChangedState<A> {
+        let components = world.components_queue();
+        let resource_id = components.queue_register_resource::<AssetChanges<A::Asset>>();
+        let asset_id = components.queue_register_component::<A>();
         AssetChangedState {
             asset_id,
             resource_id,

crates/bevy_asset/src/lib.rs

@@ -205,6 +205,7 @@ pub use server::*;
 pub use uuid;
 
 use crate::{
+    asset_changed::AssetChanges,
     io::{embedded::EmbeddedAssetRegistry, AssetSourceBuilder, AssetSourceBuilders, AssetSourceId},
     processor::{AssetProcessor, Process},
 };
@@ -650,6 +651,7 @@ impl AssetApp for App {
                 ));
         }
         self.insert_resource(assets)
+            .init_resource::<AssetChanges<A>>()
             .allow_ambiguous_resource::<Assets<A>>()
             .add_message::<AssetEvent<A>>()
             .add_message::<AssetLoadFailedEvent<A>>()

crates/bevy_core_pipeline/src/fullscreen_material.rs

@@ -99,7 +99,7 @@ impl<T: FullscreenMaterial> Plugin for FullscreenMaterialPlugin<T> {
 }
 
 fn extract_on_add<T: FullscreenMaterial>(world: &mut World) {
-    world.resource_scope::<MainWorld, ()>(|world, mut main_world| {
+    world.resource_scope::<MainWorld, ()>(|world, main_world| {
         // Extract the material from the main world
         let mut query =
             main_world.query_filtered::<(Entity, Has<Camera3d>, Has<Camera2d>), Added<T>>();

crates/bevy_ecs/macros/src/lib.rs

@@ -134,9 +134,9 @@ pub fn derive_bundle(input: TokenStream) -> TokenStream {
         // - `Bundle::get_components` is exactly once for each member. Rely's on the Component -> Bundle implementation to properly pass
         //   the correct `StorageType` into the callback.
         unsafe impl #impl_generics #ecs_path::bundle::Bundle for #struct_name #ty_generics #where_clause {
-            fn component_ids(
-                components: &mut #ecs_path::component::ComponentsRegistrator,
-            ) -> impl Iterator<Item = #ecs_path::component::ComponentId> + use<#(#generics_ty_list,)*> {
+            fn component_ids<Components: #ecs_path::component::ComponentIdDictator>(
+                components: &mut Components,
+            ) -> impl Iterator<Item = #ecs_path::component::ComponentId> + use<#(#generics_ty_list,)* Components> {
                 core::iter::empty()#(.chain(<#active_field_types as #ecs_path::bundle::Bundle>::component_ids(components)))*
             }
 

crates/bevy_ecs/macros/src/world_query.rs

@@ -156,7 +156,7 @@ pub(crate) fn world_query_impl(
                 #( <#field_types>::update_component_access(&state.#field_aliases, _access); )*
             }
 
-            fn init_state(world: &mut #path::world::World) -> #state_struct_name #user_ty_generics {
+            fn init_state(world: &#path::world::World) -> #state_struct_name #user_ty_generics {
                 #state_struct_name {
                     #(#field_aliases: <#field_types>::init_state(world),)*
                 }

crates/bevy_ecs/src/bundle/impls.rs

@@ -6,18 +6,18 @@ use variadics_please::all_tuples_enumerated;
 
 use crate::{
     bundle::{Bundle, BundleFromComponents, DynamicBundle, NoBundleEffect},
-    component::{Component, ComponentId, Components, ComponentsRegistrator, StorageType},
+    component::{Component, ComponentId, ComponentIdDictator, Components, StorageType},
     world::EntityWorldMut,
 };
 
 // SAFETY:
 // - `Bundle::component_ids` calls `ids` for C's component id (and nothing else)
 // - `Bundle::get_components` is called exactly once for C and passes the component's storage type based on its associated constant.
 unsafe impl<C: Component> Bundle for C {
-    fn component_ids(
-        components: &mut ComponentsRegistrator,
-    ) -> impl Iterator<Item = ComponentId> + use<C> {
-        iter::once(components.register_component::<C>())
+    fn component_ids<Components: ComponentIdDictator>(
+        components: &mut Components,
+    ) -> impl Iterator<Item = ComponentId> + use<C, Components> {
+        iter::once(components.determine_component_id_of::<C>())
     }
 
     fn get_component_ids(components: &Components) -> impl Iterator<Item = Option<ComponentId>> {
@@ -73,7 +73,7 @@ macro_rules! tuple_impl {
         // - `Bundle::get_components` is called exactly once for each member. Relies on the above implementation to pass the correct
         //   `StorageType` into the callback.
         unsafe impl<$($name: Bundle),*> Bundle for ($($name,)*) {
-            fn component_ids<'a>(components: &'a mut ComponentsRegistrator) -> impl Iterator<Item = ComponentId> + use<$($name,)*> {
+            fn component_ids<'a, Components: ComponentIdDictator>(components: &'a mut Components) -> impl Iterator<Item = ComponentId> + use<$($name,)* Components> {
                 iter::empty()$(.chain(<$name as Bundle>::component_ids(components)))*
             }
 

crates/bevy_ecs/src/bundle/mod.rs

@@ -77,7 +77,7 @@ pub use info::*;
 pub use bevy_ecs_macros::Bundle;
 
 use crate::{
-    component::{ComponentId, Components, ComponentsRegistrator, StorageType},
+    component::{ComponentId, ComponentIdDictator, Components, StorageType},
     world::EntityWorldMut,
 };
 use bevy_ptr::OwningPtr;
@@ -204,11 +204,11 @@ use bevy_ptr::OwningPtr;
 )]
 pub unsafe trait Bundle: DynamicBundle + Send + Sync + 'static {
     /// Gets this [`Bundle`]'s component ids, in the order of this bundle's [`Component`]s
-    /// This will register the component if it doesn't exist.
+    /// This may register the component if it doesn't exist, depending on which [`ComponentIdDictator`] is used.
     #[doc(hidden)]
-    fn component_ids(
-        components: &mut ComponentsRegistrator,
-    ) -> impl Iterator<Item = ComponentId> + use<Self>;
+    fn component_ids<Components: ComponentIdDictator>(
+        components: &mut Components,
+    ) -> impl Iterator<Item = ComponentId> + use<Self, Components>;
 
     /// Return a iterator over this [`Bundle`]'s component ids. This will be [`None`] if the component has not been registered.
     fn get_component_ids(components: &Components) -> impl Iterator<Item = Option<ComponentId>>;

crates/bevy_ecs/src/component/register.rs

@@ -698,3 +698,27 @@ impl<'w> ComponentsQueuedRegistrator<'w> {
         })
     }
 }
+
+/// Represents a way to get the id of component types.
+///
+/// This exists to encapsulate shared behavior of [`ComponentsRegistrator`] and [`ComponentsQueuedRegistrator`].
+/// If you know which one you are working with, prefer their direct methods.
+pub trait ComponentIdDictator {
+    /// Determines the [`ComponentId`] of `T`.
+    /// This makes no promises of whether or not `T` will be full registered; it just gets its id.
+    fn determine_component_id_of<T: Component>(&mut self) -> ComponentId;
+}
+
+impl ComponentIdDictator for ComponentsRegistrator<'_> {
+    #[inline]
+    fn determine_component_id_of<T: Component>(&mut self) -> ComponentId {
+        self.register_component::<T>()
+    }
+}
+
+impl ComponentIdDictator for ComponentsQueuedRegistrator<'_> {
+    #[inline]
+    fn determine_component_id_of<T: Component>(&mut self) -> ComponentId {
+        self.queue_register_component::<T>()
+    }
+}

crates/bevy_ecs/src/entity/entity_set.rs

@@ -500,7 +500,7 @@ mod tests {
     fn preserving_uniqueness() {
         let mut world = World::new();
 
-        let mut query = QueryState::<&mut Thing>::new(&mut world);
+        let mut query = QueryState::<&mut Thing>::new(&world);
 
         let spawn_batch: Vec<Entity> = world.spawn_batch(vec![Thing; 1000]).collect();
 

crates/bevy_ecs/src/lib.rs

@@ -1466,62 +1466,62 @@ mod tests {
     #[test]
     #[should_panic]
     fn ref_and_mut_query_panic() {
-        let mut world = World::new();
+        let world = World::new();
         world.query::<(&A, &mut A)>();
     }
 
     #[test]
     #[should_panic]
     fn entity_ref_and_mut_query_panic() {
-        let mut world = World::new();
+        let world = World::new();
         world.query::<(EntityRef, &mut A)>();
     }
 
     #[test]
     #[should_panic]
     fn mut_and_ref_query_panic() {
-        let mut world = World::new();
+        let world = World::new();
         world.query::<(&mut A, &A)>();
     }
 
     #[test]
     #[should_panic]
     fn mut_and_entity_ref_query_panic() {
-        let mut world = World::new();
+        let world = World::new();
         world.query::<(&mut A, EntityRef)>();
     }
 
     #[test]
     #[should_panic]
     fn entity_ref_and_entity_mut_query_panic() {
-        let mut world = World::new();
+        let world = World::new();
         world.query::<(EntityRef, EntityMut)>();
     }
 
     #[test]
     #[should_panic]
     fn entity_mut_and_entity_mut_query_panic() {
-        let mut world = World::new();
+        let world = World::new();
         world.query::<(EntityMut, EntityMut)>();
     }
 
     #[test]
     fn entity_ref_and_entity_ref_query_no_panic() {
-        let mut world = World::new();
+        let world = World::new();
         world.query::<(EntityRef, EntityRef)>();
     }
 
     #[test]
     #[should_panic]
     fn mut_and_mut_query_panic() {
-        let mut world = World::new();
+        let world = World::new();
         world.query::<(&mut A, &mut A)>();
     }
 
     #[test]
     #[should_panic]
     fn multiple_worlds_same_query_iter() {
-        let mut world_a = World::new();
+        let world_a = World::new();
         let world_b = World::new();
         let mut query = world_a.query::<&A>();
         query.iter(&world_a);
@@ -1530,7 +1530,7 @@ mod tests {
 
     #[test]
     fn query_filters_dont_collide_with_fetches() {
-        let mut world = World::new();
+        let world = World::new();
         world.query_filtered::<&mut A, Changed<A>>();
     }
 
@@ -1555,7 +1555,7 @@ mod tests {
     #[test]
     #[should_panic]
     fn multiple_worlds_same_query_get() {
-        let mut world_a = World::new();
+        let world_a = World::new();
         let world_b = World::new();
         let mut query = world_a.query::<&A>();
         let _ = query.get(&world_a, Entity::from_raw_u32(0).unwrap());
@@ -1565,7 +1565,7 @@ mod tests {
     #[test]
     #[should_panic]
     fn multiple_worlds_same_query_for_each() {
-        let mut world_a = World::new();
+        let world_a = World::new();
         let world_b = World::new();
         let mut query = world_a.query::<&A>();
         query.iter(&world_a).for_each(|_| {});

crates/bevy_ecs/src/observer/distributed_storage.rs

@@ -433,11 +433,15 @@ fn hook_on_add<E: Event, B: Bundle, S: ObserverSystem<E, B>>(
 ) {
     world.commands().queue(move |world: &mut World| {
         let event_key = world.register_event_key::<E>();
-        let components = B::component_ids(&mut world.components_registrator());
+        let components = B::component_ids(&mut world.components_registrator())
+            .collect::<smallvec::SmallVec<[ComponentId; 16]>>();
 
         if let Some(mut observer) = world.get_mut::<Observer>(entity) {
             observer.descriptor.event_keys.push(event_key);
-            observer.descriptor.components.extend(components);
+            observer
+                .descriptor
+                .components
+                .extend_from_slice(&components);
 
             let system: &mut dyn Any = observer.system.as_mut();
             let system: *mut dyn ObserverSystem<E, B> = system.downcast_mut::<S>().unwrap();