Remove Sync bound on Component and Resource

crates/bevy_ecs/macros/src/component.rs

@@ -18,7 +18,7 @@ pub fn derive_component(input: TokenStream) -> TokenStream {
     ast.generics
         .make_where_clause()
         .predicates
-        .push(parse_quote! { Self: Send + Sync + 'static });
+        .push(parse_quote! { Self: Send + 'static });
 
     let struct_name = &ast.ident;
     let (impl_generics, type_generics, where_clause) = &ast.generics.split_for_impl();

crates/bevy_ecs/src/bundle.rs

@@ -76,7 +76,7 @@ use std::{any::TypeId, collections::HashMap};
 /// bundle, in the _exact_ order that [`Bundle::get_components`] is called.
 /// - [`Bundle::from_components`] must call `func` exactly once for each [`ComponentId`] returned by
 ///   [`Bundle::component_ids`].
-pub unsafe trait Bundle: Send + Sync + 'static {
+pub unsafe trait Bundle: Send + 'static {
     /// Gets this [`Bundle`]'s component ids, in the order of this bundle's [`Component`]s
     fn component_ids(components: &mut Components, storages: &mut Storages) -> Vec<ComponentId>;
 

crates/bevy_ecs/src/component.rs

@@ -14,7 +14,7 @@ use std::{
 /// A component is data associated with an [`Entity`](crate::entity::Entity). Each entity can have
 /// multiple different types of components, but only one of them per type.
 ///
-/// Any type that is `Send + Sync + 'static` can implement `Component` using `#[derive(Component)]`.
+/// Any type that is `Send + 'static` can implement `Component` using `#[derive(Component)]`.
 ///
 /// In order to use foreign types as components, wrap them using a newtype pattern.
 /// ```
@@ -31,7 +31,7 @@ use std::{
 /// as one of the arguments.
 ///
 /// Components can be grouped together into a [`Bundle`](crate::bundle::Bundle).
-pub trait Component: Send + Sync + 'static {
+pub trait Component: Send + 'static {
     type Storage: ComponentStorage;
 }
 

crates/bevy_ecs/src/query/fetch.rs

@@ -541,7 +541,7 @@ impl<'w> Fetch<'w> for EntityFetch<'w> {
     }
 }
 
-impl<T: Component> WorldQuery for &T {
+impl<T: Component + Sync> WorldQuery for &T {
     type State = ReadState<T>;
 
     fn shrink<'wlong: 'wshort, 'wshort>(item: QueryItem<'wlong, Self>) -> QueryItem<'wshort, Self> {
@@ -556,9 +556,13 @@ pub struct ReadState<T> {
     marker: PhantomData<T>,
 }
 
+// SAFETY: ReadState only contains a ComponentId, should be safe to read
+// from multiple threads concurrently
+unsafe impl<T: Component + Sync> Sync for ReadState<T> {}
+
 // SAFETY: component access and archetype component access are properly updated to reflect that T is
 // read
-unsafe impl<T: Component> FetchState for ReadState<T> {
+unsafe impl<T: Component + Sync> FetchState for ReadState<T> {
     fn init(world: &mut World) -> Self {
         let component_id = world.init_component::<T>();
         ReadState {
@@ -620,15 +624,15 @@ impl<T> Clone for ReadFetch<'_, T> {
 }
 
 /// SAFETY: access is read only
-unsafe impl<'w, T: Component> ReadOnlyFetch for ReadFetch<'w, T> {}
+unsafe impl<'w, T: Component + Sync> ReadOnlyFetch for ReadFetch<'w, T> {}
 
-impl<'w, T: Component> WorldQueryGats<'w> for &T {
+impl<'w, T: Component + Sync> WorldQueryGats<'w> for &T {
     type Fetch = ReadFetch<'w, T>;
     type ReadOnlyFetch = ReadFetch<'w, T>;
     type _State = ReadState<T>;
 }
 
-impl<'w, T: Component> Fetch<'w> for ReadFetch<'w, T> {
+impl<'w, T: Component + Sync> Fetch<'w> for ReadFetch<'w, T> {
     type Item = &'w T;
     type State = ReadState<T>;
 
@@ -793,6 +797,10 @@ pub struct WriteState<T> {
     marker: PhantomData<T>,
 }
 
+// SAFETY: WriteState only contains a ComponentId, should be safe to read
+// from multiple threads concurrently
+unsafe impl<T: Component> Sync for WriteState<T> {}
+
 // SAFETY: component access and archetype component access are properly updated to reflect that T is
 // written
 unsafe impl<T: Component> FetchState for WriteState<T> {
@@ -1259,6 +1267,10 @@ pub struct ChangeTrackersState<T> {
     marker: PhantomData<T>,
 }
 
+// SAFETY: WriteState only contains a ComponentId, should be safe to read
+// from multiple threads concurrently
+unsafe impl<T: Component> Sync for ChangeTrackersState<T> {}
+
 // SAFETY: component access and archetype component access are properly updated to reflect that T is
 // read
 unsafe impl<T: Component> FetchState for ChangeTrackersState<T> {

crates/bevy_ecs/src/query/filter.rs

@@ -67,6 +67,10 @@ pub struct WithState<T> {
     marker: PhantomData<T>,
 }
 
+// SAFETY: WithState only contains a ComponentId, should be safe to read
+// from multiple threads concurrently
+unsafe impl<T: Component> Sync for WithState<T> {}
+
 // SAFETY: no component access or archetype component access
 unsafe impl<T: Component> FetchState for WithState<T> {
     fn init(world: &mut World) -> Self {
@@ -210,6 +214,10 @@ pub struct WithoutState<T> {
     marker: PhantomData<T>,
 }
 
+// SAFETY: WithoutState only contains a ComponentId, should be safe to read
+// from multiple threads concurrently
+unsafe impl<T: Component> Sync for WithoutState<T> {}
+
 // SAFETY: no component access or archetype component access
 unsafe impl<T: Component> FetchState for WithoutState<T> {
     fn init(world: &mut World) -> Self {
@@ -508,6 +516,10 @@ macro_rules! impl_tick_filter {
             }
         }
 
+        // SAFETY: The state only contains a ComponentId, should be safe to read
+        // from multiple threads concurrently
+        unsafe impl<T: Component> Sync for $state_name<T> {}
+
         // SAFETY: this reads the T component. archetype component access and component access are updated to reflect that
         unsafe impl<T: Component> FetchState for $state_name<T> {
             fn init(world: &mut World) -> Self {

crates/bevy_ecs/src/system/commands/mod.rs

@@ -13,7 +13,7 @@ use std::marker::PhantomData;
 use super::Resource;
 
 /// A [`World`] mutation.
-pub trait Command: Send + Sync + 'static {
+pub trait Command: Send + 'static {
     fn write(self, world: &mut World);
 }
 
@@ -261,7 +261,7 @@ impl<'w, 's> Commands<'w, 's> {
     /// worked out to share an ID space (which doesn't happen by default).
     pub fn insert_or_spawn_batch<I, B>(&mut self, bundles_iter: I)
     where
-        I: IntoIterator + Send + Sync + 'static,
+        I: IntoIterator + Send + 'static,
         I::IntoIter: Iterator<Item = (Entity, B)>,
         B: Bundle,
     {
@@ -640,7 +640,7 @@ where
 
 pub struct InsertOrSpawnBatch<I, B>
 where
-    I: IntoIterator + Send + Sync + 'static,
+    I: IntoIterator + Send + 'static,
     B: Bundle,
     I::IntoIter: Iterator<Item = (Entity, B)>,
 {
@@ -649,7 +649,7 @@ where
 
 impl<I, B> Command for InsertOrSpawnBatch<I, B>
 where
-    I: IntoIterator + Send + Sync + 'static,
+    I: IntoIterator + Send + 'static,
     B: Bundle,
     I::IntoIter: Iterator<Item = (Entity, B)>,
 {

crates/bevy_ecs/src/system/query.rs

@@ -827,7 +827,7 @@ impl<'w, 's, Q: WorldQuery, F: WorldQuery> Query<'w, 's, Q, F> {
     /// # bevy_ecs::system::assert_is_system(print_selected_character_name_system);
     /// ```
     #[inline]
-    pub fn get_component<T: Component>(&self, entity: Entity) -> Result<&T, QueryComponentError> {
+    pub fn get_component<T: Component + Sync>(&self, entity: Entity) -> Result<&T, QueryComponentError> {
         let world = self.world;
         let entity_ref = world
             .get_entity(entity)

crates/bevy_ecs/src/system/system_param.rs

@@ -714,6 +714,10 @@ pub struct RemovedComponentsState<T> {
     marker: PhantomData<T>,
 }
 
+// SAFETY: RemovedComponentState only contains a ComponentId, should be safe to read
+// from multiple threads concurrently
+unsafe impl<T: Component> Sync for RemovedComponentsState<T> {}
+
 impl<'a, T: Component> SystemParam for RemovedComponents<'a, T> {
     type Fetch = RemovedComponentsState<T>;
 }

crates/bevy_ecs/src/world/entity_ref.rs

@@ -64,7 +64,7 @@ impl<'w> EntityRef<'w> {
     }
 
     #[inline]
-    pub fn get<T: Component>(&self) -> Option<&'w T> {
+    pub fn get<T: Component + Sync>(&self) -> Option<&'w T> {
         // SAFE: entity location is valid and returned component is of type T
         unsafe {
             get_component_with_type(self.world, TypeId::of::<T>(), self.entity, self.location)
@@ -166,7 +166,7 @@ impl<'w> EntityMut<'w> {
     }
 
     #[inline]
-    pub fn get<T: Component>(&self) -> Option<&'_ T> {
+    pub fn get<T: Component + Sync>(&self) -> Option<&'_ T> {
         // SAFE: lifetimes enforce correct usage of returned borrow
         unsafe {
             get_component_with_type(self.world, TypeId::of::<T>(), self.entity, self.location)

crates/bevy_ecs/src/world/mod.rs

@@ -413,7 +413,7 @@ impl World {
     /// assert_eq!(position.x, 0.0);
     /// ```
     #[inline]
-    pub fn get<T: Component>(&self, entity: Entity) -> Option<&T> {
+    pub fn get<T: Component + Sync>(&self, entity: Entity) -> Option<&T> {
         self.get_entity(entity)?.get()
     }
 

crates/bevy_ecs_compile_fail_tests/tests/ui/non_sync_ref.rs

@@ -0,0 +1,26 @@
+use bevy_ecs::prelude::*;
+use std::cell::Cell;
+
+#[derive(Component, Eq, PartialEq, Debug)]
+struct A(Cell<usize>);
+
+fn main() {
+    let mut world = World::default();
+    let e = world.spawn().insert(A(Cell::new(10_usize))).id();
+
+    {
+        let query = QueryState::<&A>::new(&mut world);
+    }
+
+    {
+        let value = world.get::<A>(e);
+    }
+
+    {
+        let value = world.entity(e).get::<A>();
+    }
+
+    {
+        let value = world.entity_mut(e).get::<A>();
+    }
+}

crates/bevy_ecs_compile_fail_tests/tests/ui/non_sync_ref.stderr

@@ -0,0 +1,81 @@
+error[E0599]: the function or associated item `new` exists for struct `bevy_ecs::query::QueryState<&A>`, but its trait bounds were not satisfied
+  --> tests/ui/non_sync_ref.rs:12:39
+   |
+12 |         let query = QueryState::<&A>::new(&mut world);
+   |                                       ^^^ function or associated item cannot be called on `bevy_ecs::query::QueryState<&A>` due to unsatisfied trait bounds
+   |
+   = note: the following trait bounds were not satisfied:
+           `&A: WorldQuery`
+
+error[E0277]: `Cell<usize>` cannot be shared between threads safely
+  --> tests/ui/non_sync_ref.rs:12:21
+   |
+12 |         let query = QueryState::<&A>::new(&mut world);
+   |                     ^^^^^^^^^^^^^^^^ `Cell<usize>` cannot be shared between threads safely
+   |
+   = help: within `A`, the trait `Sync` is not implemented for `Cell<usize>`
+note: required because it appears within the type `A`
+  --> tests/ui/non_sync_ref.rs:5:8
+   |
+5  | struct A(Cell<usize>);
+   |        ^
+   = note: required because of the requirements on the impl of `WorldQuery` for `&A`
+note: required by a bound in `bevy_ecs::query::QueryState`
+  --> C:/Users/James/Git/bevy/crates/bevy_ecs/src/query/state.rs:20:26
+   |
+20 | pub struct QueryState<Q: WorldQuery, F: WorldQuery = ()> {
+   |                          ^^^^^^^^^^ required by this bound in `bevy_ecs::query::QueryState`
+
+error[E0277]: `Cell<usize>` cannot be shared between threads safely
+   --> tests/ui/non_sync_ref.rs:16:27
+    |
+16  |         let value = world.get::<A>(e);
+    |                           ^^^ `Cell<usize>` cannot be shared between threads safely
+    |
+    = help: within `A`, the trait `Sync` is not implemented for `Cell<usize>`
+note: required because it appears within the type `A`
+   --> tests/ui/non_sync_ref.rs:5:8
+    |
+5   | struct A(Cell<usize>);
+    |        ^
+note: required by a bound in `bevy_ecs::world::World::get`
+   --> C:/Users/James/Git/bevy/crates/bevy_ecs/src/world/mod.rs:416:31
+    |
+416 |     pub fn get<T: Component + Sync>(&self, entity: Entity) -> Option<&T> {
+    |                               ^^^^ required by this bound in `bevy_ecs::world::World::get`
+
+error[E0277]: `Cell<usize>` cannot be shared between threads safely
+  --> tests/ui/non_sync_ref.rs:20:37
+   |
+20 |         let value = world.entity(e).get::<A>();
+   |                                     ^^^ `Cell<usize>` cannot be shared between threads safely
+   |
+   = help: within `A`, the trait `Sync` is not implemented for `Cell<usize>`
+note: required because it appears within the type `A`
+  --> tests/ui/non_sync_ref.rs:5:8
+   |
+5  | struct A(Cell<usize>);
+   |        ^
+note: required by a bound in `EntityRef::<'w>::get`
+  --> C:/Users/James/Git/bevy/crates/bevy_ecs/src/world/entity_ref.rs:67:31
+   |
+67 |     pub fn get<T: Component + Sync>(&self) -> Option<&'w T> {
+   |                               ^^^^ required by this bound in `EntityRef::<'w>::get`
+
+error[E0277]: `Cell<usize>` cannot be shared between threads safely
+   --> tests/ui/non_sync_ref.rs:24:41
+    |
+24  |         let value = world.entity_mut(e).get::<A>();
+    |                                         ^^^ `Cell<usize>` cannot be shared between threads safely
+    |
+    = help: within `A`, the trait `Sync` is not implemented for `Cell<usize>`
+note: required because it appears within the type `A`
+   --> tests/ui/non_sync_ref.rs:5:8
+    |
+5   | struct A(Cell<usize>);
+    |        ^
+note: required by a bound in `EntityMut::<'w>::get`
+   --> C:/Users/James/Git/bevy/crates/bevy_ecs/src/world/entity_ref.rs:169:31
+    |
+169 |     pub fn get<T: Component + Sync>(&self) -> Option<&'_ T> {
+    |                               ^^^^ required by this bound in `EntityMut::<'w>::get`

crates/bevy_render/src/camera/camera.rs

@@ -238,7 +238,7 @@ impl<T: Component + Default> Default for CameraTypePlugin<T> {
     }
 }
 
-impl<T: Component + Default> Plugin for CameraTypePlugin<T> {
+impl<T: Component + Sync + Default> Plugin for CameraTypePlugin<T> {
     fn build(&self, app: &mut App) {
         app.init_resource::<ActiveCamera<T>>()
             .add_startup_system_to_stage(StartupStage::PostStartup, set_active_camera::<T>)
@@ -251,12 +251,12 @@ impl<T: Component + Default> Plugin for CameraTypePlugin<T> {
 
 /// The canonical source of the "active camera" of the given camera type `T`.
 #[derive(Debug)]
-pub struct ActiveCamera<T: Component> {
+pub struct ActiveCamera<T: Component + Sync> {
     camera: Option<Entity>,
     marker: PhantomData<T>,
 }
 
-impl<T: Component> Default for ActiveCamera<T> {
+impl<T: Component + Sync> Default for ActiveCamera<T> {
     fn default() -> Self {
         Self {
             camera: Default::default(),
@@ -265,7 +265,7 @@ impl<T: Component> Default for ActiveCamera<T> {
     }
 }
 
-impl<T: Component> Clone for ActiveCamera<T> {
+impl<T: Component + Sync> Clone for ActiveCamera<T> {
     fn clone(&self) -> Self {
         Self {
             camera: self.camera,
@@ -274,7 +274,7 @@ impl<T: Component> Clone for ActiveCamera<T> {
     }
 }
 
-impl<T: Component> ActiveCamera<T> {
+impl<T: Component + Sync> ActiveCamera<T> {
     /// Sets the active camera to the given `camera` entity.
     pub fn set(&mut self, camera: Entity) {
         self.camera = Some(camera);
@@ -286,7 +286,7 @@ impl<T: Component> ActiveCamera<T> {
     }
 }
 
-pub fn set_active_camera<T: Component>(
+pub fn set_active_camera<T: Component + Sync>(
     mut active_camera: ResMut<ActiveCamera<T>>,
     cameras: Query<Entity, (With<Camera>, With<T>)>,
 ) {
@@ -313,7 +313,7 @@ pub struct ExtractedCamera {
     pub physical_size: Option<UVec2>,
 }
 
-pub fn extract_cameras<M: Component + Default>(
+pub fn extract_cameras<M: Component + Sync + Default>(
     mut commands: Commands,
     windows: Res<Windows>,
     images: Res<Assets<Image>>,