Remove Send + Sync bounds from PartialReflect and friends (and move the constraint to usages thereof)

Cargo.toml

@@ -10,7 +10,7 @@ keywords = ["game", "engine", "gamedev", "graphics", "bevy"]
 license = "MIT OR Apache-2.0"
 repository = "https://github.com/bevyengine/bevy"
 documentation = "https://docs.rs/bevy"
-rust-version = "1.85.0"
+rust-version = "1.86.0"
 
 [workspace]
 resolver = "2"

benches/benches/bevy_reflect/list.rs

@@ -47,7 +47,7 @@ fn list_apply<M, LBase, LPatch, F1, F2, F3>(
 ) where
     M: Measurement,
     LBase: List,
-    LPatch: List,
+    LPatch: List + Send + Sync,
     F1: Fn(usize) -> F2,
     F2: Fn() -> LBase,
     F3: Fn(usize) -> LPatch,

benches/benches/bevy_reflect/map.rs

@@ -53,7 +53,7 @@ fn map_apply<M, MBase, MPatch, F1, F2, F3>(
 ) where
     M: Measurement,
     MBase: Map,
-    MPatch: Map,
+    MPatch: Map + Send + Sync,
     F1: Fn(usize) -> F2,
     F2: Fn() -> MBase,
     F3: Fn(usize) -> MPatch,

benches/benches/bevy_reflect/struct.rs

@@ -73,7 +73,7 @@ fn concrete_struct_apply(criterion: &mut Criterion) {
 
     // Use functions that produce trait objects of varying concrete types as the
     // input to the benchmark.
-    let inputs: &[fn() -> (Box<dyn Struct>, Box<dyn PartialReflect>)] = &[
+    let inputs: &[fn() -> (Box<dyn Struct>, Box<dyn PartialReflect + Send + Sync>)] = &[
         || (Box::new(Struct16::default()), Box::new(Struct16::default())),
         || (Box::new(Struct32::default()), Box::new(Struct32::default())),
         || (Box::new(Struct64::default()), Box::new(Struct64::default())),
@@ -243,7 +243,7 @@ fn dynamic_struct_to_dynamic_struct(criterion: &mut Criterion) {
 fn dynamic_struct_apply(criterion: &mut Criterion) {
     let mut group = create_group(criterion, bench!("dynamic_struct_apply"));
 
-    let patches: &[(fn() -> Box<dyn PartialReflect>, usize)] = &[
+    let patches: &[(fn() -> Box<dyn PartialReflect + Send + Sync>, usize)] = &[
         (|| Box::new(Struct16::default()), 16),
         (|| Box::new(Struct32::default()), 32),
         (|| Box::new(Struct64::default()), 64),
@@ -612,12 +612,12 @@ struct Struct128 {
 }
 
 #[derive(Clone, Default, Reflect)]
-struct GenericStruct1<T: Reflect + Default> {
+struct GenericStruct1<T: Reflect + Send + Sync + Default> {
     field_0: T,
 }
 
 #[derive(Clone, Default, Reflect)]
-struct GenericStruct16<T: Reflect + Default> {
+struct GenericStruct16<T: Reflect + Send + Sync + Default> {
     field_0: T,
     field_1: T,
     field_2: T,
@@ -637,7 +637,7 @@ struct GenericStruct16<T: Reflect + Default> {
 }
 
 #[derive(Clone, Default, Reflect)]
-struct GenericStruct32<T: Reflect + Default> {
+struct GenericStruct32<T: Reflect + Send + Sync + Default> {
     field_0: T,
     field_1: T,
     field_2: T,
@@ -673,7 +673,7 @@ struct GenericStruct32<T: Reflect + Default> {
 }
 
 #[derive(Clone, Default, Reflect)]
-struct GenericStruct64<T: Reflect + Default> {
+struct GenericStruct64<T: Reflect + Send + Sync + Default> {
     field_0: T,
     field_1: T,
     field_2: T,
@@ -741,7 +741,7 @@ struct GenericStruct64<T: Reflect + Default> {
 }
 
 #[derive(Clone, Default, Reflect)]
-struct GenericStruct128<T: Reflect + Default> {
+struct GenericStruct128<T: Reflect + Send + Sync + Default> {
     field_0: T,
     field_1: T,
     field_2: T,

crates/bevy_animation/src/animation_curves.rs

@@ -347,7 +347,7 @@ where
 impl<P: Send + Sync + 'static, C> AnimationCurve for AnimatableCurve<P, C>
 where
     P: AnimatableProperty + Clone,
-    C: AnimationCompatibleCurve<P::Property> + Clone,
+    C: AnimationCompatibleCurve<P::Property> + Clone + Send + Sync,
 {
     fn clone_value(&self) -> Box<dyn AnimationCurve> {
         Box::new(self.clone())
@@ -469,7 +469,7 @@ struct WeightsCurveEvaluator {
 
 impl<C> AnimationCurve for WeightsCurve<C>
 where
-    C: IterableCurve<f32> + Debug + Clone + Reflectable,
+    C: IterableCurve<f32> + Debug + Clone + Reflectable + Send + Sync,
 {
     fn clone_value(&self) -> Box<dyn AnimationCurve> {
         Box::new(self.clone())

crates/bevy_app/src/app.rs

@@ -620,7 +620,7 @@ impl App {
     /// See [`bevy_reflect::TypeRegistry::register_type_data`].
     #[cfg(feature = "bevy_reflect")]
     pub fn register_type_data<
-        T: bevy_reflect::Reflect + bevy_reflect::TypePath,
+        T: bevy_reflect::Reflect + Send + Sync + bevy_reflect::TypePath,
         D: bevy_reflect::TypeData + bevy_reflect::FromType<T>,
     >(
         &mut self,

crates/bevy_app/src/sub_app.rs

@@ -434,7 +434,7 @@ impl SubApp {
     /// See [`App::register_type_data`].
     #[cfg(feature = "bevy_reflect")]
     pub fn register_type_data<
-        T: bevy_reflect::Reflect + bevy_reflect::TypePath,
+        T: bevy_reflect::Reflect + Send + Sync + bevy_reflect::TypePath,
         D: bevy_reflect::TypeData + bevy_reflect::FromType<T>,
     >(
         &mut self,

crates/bevy_asset/src/handle.rs

@@ -691,16 +691,17 @@ mod tests {
                     "Inserting the asset should result in a strong count of 1"
                 );
 
-                let reflected: &dyn Reflect = &handle;
-                let _cloned_handle: Box<dyn Reflect> = reflected.reflect_clone().unwrap();
+                let reflected: &(dyn Reflect + Send + Sync) = &handle;
+                let _cloned_handle: Box<dyn Reflect + Send + Sync> =
+                    reflected.reflect_clone().unwrap();
 
                 assert_eq!(
                     Arc::strong_count(strong),
                     2,
                     "Cloning the handle with reflect should increase the strong count to 2"
                 );
 
-                let dynamic_handle: Box<dyn PartialReflect> = reflected.to_dynamic();
+                let dynamic_handle: Box<dyn PartialReflect + Send + Sync> = reflected.to_dynamic();
 
                 assert_eq!(
                     Arc::strong_count(strong),

crates/bevy_asset/src/reflect.rs

@@ -18,16 +18,17 @@ pub struct ReflectAsset {
     handle_type_id: TypeId,
     assets_resource_type_id: TypeId,
 
-    get: fn(&World, UntypedHandle) -> Option<&dyn Reflect>,
+    get: fn(&World, UntypedHandle) -> Option<&(dyn Reflect + Send + Sync)>,
     // SAFETY:
     // - may only be called with an [`UnsafeWorldCell`] which can be used to access the corresponding `Assets<T>` resource mutably
     // - may only be used to access **at most one** access at once
-    get_unchecked_mut: unsafe fn(UnsafeWorldCell<'_>, UntypedHandle) -> Option<&mut dyn Reflect>,
-    add: fn(&mut World, &dyn PartialReflect) -> UntypedHandle,
-    insert: fn(&mut World, UntypedHandle, &dyn PartialReflect),
+    get_unchecked_mut:
+        unsafe fn(UnsafeWorldCell<'_>, UntypedHandle) -> Option<&mut (dyn Reflect + Send + Sync)>,
+    add: fn(&mut World, &(dyn PartialReflect + Send + Sync)) -> UntypedHandle,
+    insert: fn(&mut World, UntypedHandle, &(dyn PartialReflect + Send + Sync)),
     len: fn(&World) -> usize,
     ids: for<'w> fn(&'w World) -> Box<dyn Iterator<Item = UntypedAssetId> + 'w>,
-    remove: fn(&mut World, UntypedHandle) -> Option<Box<dyn Reflect>>,
+    remove: fn(&mut World, UntypedHandle) -> Option<Box<dyn Reflect + Send + Sync>>,
 }
 
 impl ReflectAsset {
@@ -42,7 +43,11 @@ impl ReflectAsset {
     }
 
     /// Equivalent of [`Assets::get`]
-    pub fn get<'w>(&self, world: &'w World, handle: UntypedHandle) -> Option<&'w dyn Reflect> {
+    pub fn get<'w>(
+        &self,
+        world: &'w World,
+        handle: UntypedHandle,
+    ) -> Option<&'w (dyn Reflect + Send + Sync)> {
         (self.get)(world, handle)
     }
 
@@ -51,7 +56,7 @@ impl ReflectAsset {
         &self,
         world: &'w mut World,
         handle: UntypedHandle,
-    ) -> Option<&'w mut dyn Reflect> {
+    ) -> Option<&'w mut (dyn Reflect + Send + Sync)> {
         // SAFETY: unique world access
         #[expect(
             unsafe_code,
@@ -97,22 +102,35 @@ impl ReflectAsset {
         &self,
         world: UnsafeWorldCell<'w>,
         handle: UntypedHandle,
-    ) -> Option<&'w mut dyn Reflect> {
+    ) -> Option<&'w mut (dyn Reflect + Send + Sync)> {
         // SAFETY: requirements are deferred to the caller
         unsafe { (self.get_unchecked_mut)(world, handle) }
     }
 
     /// Equivalent of [`Assets::add`]
-    pub fn add(&self, world: &mut World, value: &dyn PartialReflect) -> UntypedHandle {
+    pub fn add(
+        &self,
+        world: &mut World,
+        value: &(dyn PartialReflect + Send + Sync),
+    ) -> UntypedHandle {
         (self.add)(world, value)
     }
     /// Equivalent of [`Assets::insert`]
-    pub fn insert(&self, world: &mut World, handle: UntypedHandle, value: &dyn PartialReflect) {
+    pub fn insert(
+        &self,
+        world: &mut World,
+        handle: UntypedHandle,
+        value: &(dyn PartialReflect + Send + Sync),
+    ) {
         (self.insert)(world, handle, value);
     }
 
     /// Equivalent of [`Assets::remove`]
-    pub fn remove(&self, world: &mut World, handle: UntypedHandle) -> Option<Box<dyn Reflect>> {
+    pub fn remove(
+        &self,
+        world: &mut World,
+        handle: UntypedHandle,
+    ) -> Option<Box<dyn Reflect + Send + Sync>> {
         (self.remove)(world, handle)
     }
 
@@ -140,15 +158,15 @@ impl<A: Asset + FromReflect> FromType<A> for ReflectAsset {
             get: |world, handle| {
                 let assets = world.resource::<Assets<A>>();
                 let asset = assets.get(&handle.typed_debug_checked());
-                asset.map(|asset| asset as &dyn Reflect)
+                asset.map(|asset| asset as &(dyn Reflect + Send + Sync))
             },
             get_unchecked_mut: |world, handle| {
                 // SAFETY: `get_unchecked_mut` must be called with `UnsafeWorldCell` having access to `Assets<A>`,
                 // and must ensure to only have at most one reference to it live at all times.
                 #[expect(unsafe_code, reason = "Uses `UnsafeWorldCell::get_resource_mut()`.")]
                 let assets = unsafe { world.get_resource_mut::<Assets<A>>().unwrap().into_inner() };
                 let asset = assets.get_mut(&handle.typed_debug_checked());
-                asset.map(|asset| asset as &mut dyn Reflect)
+                asset.map(|asset| asset as &mut (dyn Reflect + Send + Sync))
             },
             add: |world, value| {
                 let mut assets = world.resource_mut::<Assets<A>>();
@@ -173,15 +191,15 @@ impl<A: Asset + FromReflect> FromType<A> for ReflectAsset {
             remove: |world, handle| {
                 let mut assets = world.resource_mut::<Assets<A>>();
                 let value = assets.remove(&handle.typed_debug_checked());
-                value.map(|value| Box::new(value) as Box<dyn Reflect>)
+                value.map(|value| Box::new(value) as Box<dyn Reflect + Send + Sync>)
             },
         }
     }
 }
 
 /// Reflect type data struct relating a [`Handle<T>`] back to the `T` asset type.
 ///
-/// Say you want to look up the asset values of a list of handles when you have access to their `&dyn Reflect` form.
+/// Say you want to look up the asset values of a list of handles when you have access to their `&(dyn Reflect + Send + Sync)` form.
 /// Assets can be looked up in the world using [`ReflectAsset`], but how do you determine which [`ReflectAsset`] to use when
 /// only looking at the handle? [`ReflectHandle`] is stored in the type registry on each `Handle<T>` type, so you can use [`ReflectHandle::asset_type_id`] to look up
 /// the [`ReflectAsset`] type data on the corresponding `T` asset type:
@@ -194,7 +212,7 @@ impl<A: Asset + FromReflect> FromType<A> for ReflectAsset {
 ///
 /// # let world: &World = unimplemented!();
 /// # let type_registry: TypeRegistry = unimplemented!();
-/// let handles: Vec<&dyn Reflect> = unimplemented!();
+/// let handles: Vec<&(dyn Reflect + Send + Sync)> = unimplemented!();
 /// for handle in handles {
 ///     let reflect_handle = type_registry.get_type_data::<ReflectHandle>(handle.type_id()).unwrap();
 ///     let reflect_asset = type_registry.get_type_data::<ReflectAsset>(reflect_handle.asset_type_id()).unwrap();
@@ -208,7 +226,7 @@ impl<A: Asset + FromReflect> FromType<A> for ReflectAsset {
 pub struct ReflectHandle {
     asset_type_id: TypeId,
     downcast_handle_untyped: fn(&dyn Any) -> Option<UntypedHandle>,
-    typed: fn(UntypedHandle) -> Box<dyn Reflect>,
+    typed: fn(UntypedHandle) -> Box<dyn Reflect + Send + Sync>,
 }
 impl ReflectHandle {
     /// The [`TypeId`] of the asset
@@ -221,9 +239,9 @@ impl ReflectHandle {
         (self.downcast_handle_untyped)(handle)
     }
 
-    /// A way to go from a [`UntypedHandle`] to a [`Handle<T>`] in a `Box<dyn Reflect>`.
+    /// A way to go from a [`UntypedHandle`] to a [`Handle<T>`] in a `Box<dyn Reflect + Send + Sync>`.
     /// Equivalent of [`UntypedHandle::typed`].
-    pub fn typed(&self, handle: UntypedHandle) -> Box<dyn Reflect> {
+    pub fn typed(&self, handle: UntypedHandle) -> Box<dyn Reflect + Send + Sync> {
         (self.typed)(handle)
     }
 }

crates/bevy_color/Cargo.toml

@@ -7,7 +7,7 @@ homepage = "https://bevyengine.org"
 repository = "https://github.com/bevyengine/bevy"
 license = "MIT OR Apache-2.0"
 keywords = ["bevy", "color"]
-rust-version = "1.85.0"
+rust-version = "1.86.0"
 
 [dependencies]
 bevy_math = { path = "../bevy_math", version = "0.16.0-dev", default-features = false, features = [

crates/bevy_dev_tools/src/picking_debug.rs

@@ -129,7 +129,7 @@ pub fn log_event_debug<E: Event + Debug>(mut events: EventReader<pointer::Pointe
 }
 
 /// Listens for pointer events of type `E` and logs them at "debug" level
-pub fn log_pointer_event_debug<E: Debug + Clone + Reflect>(
+pub fn log_pointer_event_debug<E: Debug + Clone + Reflect + Send + Sync>(
     mut pointer_events: EventReader<Pointer<E>>,
 ) {
     for event in pointer_events.read() {
@@ -138,7 +138,7 @@ pub fn log_pointer_event_debug<E: Debug + Clone + Reflect>(
 }
 
 /// Listens for pointer events of type `E` and logs them at "trace" level
-pub fn log_pointer_event_trace<E: Debug + Clone + Reflect>(
+pub fn log_pointer_event_trace<E: Debug + Clone + Reflect + Send + Sync>(
     mut pointer_events: EventReader<Pointer<E>>,
 ) {
     for event in pointer_events.read() {

crates/bevy_ecs/Cargo.toml

@@ -8,7 +8,7 @@ repository = "https://github.com/bevyengine/bevy"
 license = "MIT OR Apache-2.0"
 keywords = ["ecs", "game", "bevy"]
 categories = ["game-engines", "data-structures"]
-rust-version = "1.85.0"
+rust-version = "1.86.0"
 
 [features]
 default = ["std", "bevy_reflect", "async_executor", "backtrace"]

crates/bevy_ecs/src/entity/clone_entities.rs

@@ -43,7 +43,7 @@ impl<'a> SourceComponent<'a> {
         self.ptr
     }
 
-    /// Returns a reference to the component on the source entity as [`&dyn Reflect`](bevy_reflect::Reflect).
+    /// Returns a reference to the component on the source entity as [`&(dyn Reflect + Send + Sync)`](bevy_reflect::Reflect).
     ///
     /// Will return `None` if:
     /// - World does not have [`AppTypeRegistry`](`crate::reflect::AppTypeRegistry`).
@@ -55,7 +55,7 @@ impl<'a> SourceComponent<'a> {
     pub fn read_reflect(
         &self,
         registry: &bevy_reflect::TypeRegistry,
-    ) -> Option<&dyn bevy_reflect::Reflect> {
+    ) -> Option<&(dyn bevy_reflect::Reflect + Send + Sync)> {
         let type_id = self.info.type_id()?;
         let reflect_from_ptr = registry.get_type_data::<bevy_reflect::ReflectFromPtr>(type_id)?;
         if reflect_from_ptr.type_id() != type_id {
@@ -219,7 +219,10 @@ impl<'a, 'b> ComponentCloneCtx<'a, 'b> {
     /// - Passed component's [`TypeId`] does not match source component [`TypeId`].
     /// - Component has already been written once.
     #[cfg(feature = "bevy_reflect")]
-    pub fn write_target_component_reflect(&mut self, component: Box<dyn bevy_reflect::Reflect>) {
+    pub fn write_target_component_reflect(
+        &mut self,
+        component: Box<dyn bevy_reflect::Reflect + Send + Sync>,
+    ) {
         if self.target_component_written {
             panic!("Trying to write component multiple times")
         }