implement and require derive(Component)

Author: Frizi

crates/bevy_app/src/app_builder.rs

@@ -4,12 +4,12 @@ use crate::{
     CoreStage, PluginGroup, PluginGroupBuilder, StartupStage,
 };
 use bevy_ecs::{
-    component::{Component, ComponentDescriptor},
+    component::ComponentDescriptor,
     event::Events,
     schedule::{
         RunOnce, Schedule, Stage, StageLabel, State, SystemDescriptor, SystemSet, SystemStage,
     },
-    system::{IntoExclusiveSystem, IntoSystem},
+    system::{IntoExclusiveSystem, IntoSystem, Resource},
     world::{FromWorld, World},
 };
 use bevy_utils::tracing::debug;
@@ -252,7 +252,7 @@ impl AppBuilder {
     /// adding [State::get_driver] to additional stages you need it in.
     pub fn add_state<T>(&mut self, initial: T) -> &mut Self
     where
-        T: Component + Debug + Clone + Eq + Hash,
+        T: Resource + Debug + Clone + Eq + Hash,
     {
         self.add_state_to_stage(CoreStage::Update, initial)
     }
@@ -264,7 +264,7 @@ impl AppBuilder {
     /// stages you need it in.
     pub fn add_state_to_stage<T>(&mut self, stage: impl StageLabel, initial: T) -> &mut Self
     where
-        T: Component + Debug + Clone + Eq + Hash,
+        T: Resource + Debug + Clone + Eq + Hash,
     {
         self.insert_resource(State::new(initial))
             .add_system_set_to_stage(stage, State::<T>::get_driver())
@@ -292,7 +292,7 @@ impl AppBuilder {
     /// and inserting a `Events::<T>::update_system` system into `CoreStage::First`.
     pub fn add_event<T>(&mut self) -> &mut Self
     where
-        T: Component,
+        T: Resource,
     {
         self.insert_resource(Events::<T>::default())
             .add_system_to_stage(CoreStage::First, Events::<T>::update_system.system())
@@ -318,7 +318,7 @@ impl AppBuilder {
     /// ```
     pub fn insert_resource<T>(&mut self, resource: T) -> &mut Self
     where
-        T: Component,
+        T: Resource,
     {
         self.app.world.insert_resource(resource);
         self

crates/bevy_asset/src/handle.rs

@@ -9,7 +9,7 @@ use crate::{
     path::{AssetPath, AssetPathId},
     Asset, Assets,
 };
-use bevy_ecs::reflect::ReflectComponent;
+use bevy_ecs::{component::Component, reflect::ReflectComponent};
 use bevy_reflect::{Reflect, ReflectDeserialize};
 use bevy_utils::Uuid;
 use crossbeam_channel::{Receiver, Sender};
@@ -58,7 +58,7 @@ impl HandleId {
 ///
 /// Handles contain a unique id that corresponds to a specific asset in the [Assets](crate::Assets)
 /// collection.
-#[derive(Reflect)]
+#[derive(Component, Reflect)]
 #[reflect(Component)]
 pub struct Handle<T>
 where

crates/bevy_asset/src/loader.rs

@@ -3,10 +3,7 @@ use crate::{
     RefChangeChannel,
 };
 use anyhow::Result;
-use bevy_ecs::{
-    component::Component,
-    system::{Res, ResMut},
-};
+use bevy_ecs::system::{Res, ResMut};
 use bevy_reflect::{TypeUuid, TypeUuidDynamic};
 use bevy_tasks::TaskPool;
 use bevy_utils::{BoxedFuture, HashMap};
@@ -146,20 +143,20 @@ impl<'a> LoadContext<'a> {
 
 /// The result of loading an asset of type `T`
 #[derive(Debug)]
-pub struct AssetResult<T: Component> {
+pub struct AssetResult<T> {
     pub asset: Box<T>,
     pub id: HandleId,
     pub version: usize,
 }
 
 /// A channel to send and receive [AssetResult]s
 #[derive(Debug)]
-pub struct AssetLifecycleChannel<T: Component> {
+pub struct AssetLifecycleChannel<T> {
     pub sender: Sender<AssetLifecycleEvent<T>>,
     pub receiver: Receiver<AssetLifecycleEvent<T>>,
 }
 
-pub enum AssetLifecycleEvent<T: Component> {
+pub enum AssetLifecycleEvent<T> {
     Create(AssetResult<T>),
     Free(HandleId),
 }
@@ -193,7 +190,7 @@ impl<T: AssetDynamic> AssetLifecycle for AssetLifecycleChannel<T> {
     }
 }
 
-impl<T: Component> Default for AssetLifecycleChannel<T> {
+impl<T> Default for AssetLifecycleChannel<T> {
     fn default() -> Self {
         let (sender, receiver) = crossbeam_channel::unbounded();
         AssetLifecycleChannel { sender, receiver }

crates/bevy_core/src/label.rs

@@ -1,4 +1,5 @@
 use bevy_ecs::{
+    component::Component,
     entity::Entity,
     query::Changed,
     reflect::ReflectComponent,
@@ -13,7 +14,7 @@ use std::{
 };
 
 /// A collection of labels
-#[derive(Default, Reflect)]
+#[derive(Component, Default, Reflect)]
 #[reflect(Component)]
 pub struct Labels {
     labels: HashSet<Cow<'static, str>>,

crates/bevy_core/src/name.rs

@@ -1,4 +1,4 @@
-use bevy_ecs::reflect::ReflectComponent;
+use bevy_ecs::{component::Component, reflect::ReflectComponent};
 use bevy_reflect::Reflect;
 use bevy_utils::AHasher;
 use std::{
@@ -8,7 +8,7 @@ use std::{
 };
 
 /// Component used to identify an entity. Stores a hash for faster comparisons
-#[derive(Debug, Clone, Reflect)]
+#[derive(Component, Debug, Clone, Reflect)]
 #[reflect(Component)]
 pub struct Name {
     hash: u64, // TODO: Shouldn't be serialized

crates/bevy_core/src/time/stopwatch.rs

@@ -1,4 +1,4 @@
-use bevy_ecs::reflect::ReflectComponent;
+use bevy_ecs::{component::Component, reflect::ReflectComponent};
 use bevy_reflect::Reflect;
 use bevy_utils::Duration;
 
@@ -23,7 +23,7 @@ use bevy_utils::Duration;
 /// assert!(stopwatch.paused());
 /// assert_eq!(stopwatch.elapsed_secs(), 0.0);
 /// ```
-#[derive(Clone, Debug, Default, Reflect)]
+#[derive(Component, Clone, Debug, Default, Reflect)]
 #[reflect(Component)]
 pub struct Stopwatch {
     elapsed: Duration,

crates/bevy_core/src/time/timer.rs

@@ -1,5 +1,5 @@
 use crate::Stopwatch;
-use bevy_ecs::reflect::ReflectComponent;
+use bevy_ecs::{component::Component, reflect::ReflectComponent};
 use bevy_reflect::Reflect;
 use bevy_utils::Duration;
 
@@ -10,7 +10,7 @@ use bevy_utils::Duration;
 /// exceeded, and can still be reset at any given point.
 ///
 /// Paused timers will not have elapsed time increased.
-#[derive(Clone, Debug, Default, Reflect)]
+#[derive(Component, Clone, Debug, Default, Reflect)]
 #[reflect(Component)]
 pub struct Timer {
     stopwatch: Stopwatch,

crates/bevy_ecs/macros/src/component.rs

@@ -0,0 +1,20 @@
+use proc_macro::TokenStream;
+use quote::quote;
+use syn::{parse_macro_input, parse_quote, DeriveInput, Path};
+
+pub fn derive_component(input: TokenStream) -> TokenStream {
+    let mut ast = parse_macro_input!(input as DeriveInput);
+    let bevy_ecs_path: Path = crate::bevy_ecs_path();
+
+    ast.generics
+        .make_where_clause()
+        .predicates
+        .push(parse_quote! { Self: Send + Sync + 'static });
+
+    let struct_name = &ast.ident;
+    let (impl_generics, type_generics, where_clause) = &ast.generics.split_for_impl();
+
+    TokenStream::from(quote! {
+        impl #impl_generics #bevy_ecs_path::component::Component for #struct_name #type_generics #where_clause {}
+    })
+}

crates/bevy_ecs/macros/src/lib.rs

@@ -1,5 +1,7 @@
 extern crate proc_macro;
 
+mod component;
+
 use bevy_macro_utils::BevyManifest;
 use proc_macro::TokenStream;
 use proc_macro2::{Span, TokenStream as TokenStream2};
@@ -470,6 +472,11 @@ fn derive_label(input: DeriveInput, label_type: Ident) -> TokenStream2 {
     }
 }
 
-fn bevy_ecs_path() -> syn::Path {
+pub(crate) fn bevy_ecs_path() -> syn::Path {
     BevyManifest::default().get_path("bevy_ecs")
 }
+
+#[proc_macro_derive(Component)]
+pub fn derive_component(input: TokenStream) -> TokenStream {
+    component::derive_component(input)
+}

crates/bevy_ecs/src/change_detection.rs

@@ -1,4 +1,4 @@
-use crate::component::{Component, ComponentTicks};
+use crate::{component::ComponentTicks, system::Resource};
 use bevy_reflect::Reflect;
 use std::ops::{Deref, DerefMut};
 
@@ -141,14 +141,14 @@ pub(crate) struct Ticks<'a> {
 /// Panics when used as a [`SystemParameter`](crate::system::SystemParam) if the resource does not exist.
 ///
 /// Use `Option<ResMut<T>>` instead if the resource might not always exist.
-pub struct ResMut<'a, T: Component> {
+pub struct ResMut<'a, T: Resource> {
     pub(crate) value: &'a mut T,
     pub(crate) ticks: Ticks<'a>,
 }
 
-change_detection_impl!(ResMut<'a, T>, T, Component);
-impl_into_inner!(ResMut<'a, T>, T, Component);
-impl_debug!(ResMut<'a, T>, Component);
+change_detection_impl!(ResMut<'a, T>, T, Resource);
+impl_into_inner!(ResMut<'a, T>, T, Resource);
+impl_debug!(ResMut<'a, T>, Resource);
 
 /// Unique mutable borrow of an entity's component
 pub struct Mut<'a, T> {

crates/bevy_ecs/src/component/mod.rs

@@ -2,7 +2,8 @@ mod type_info;
 
 pub use type_info::*;
 
-use crate::storage::SparseSetIndex;
+use crate::{storage::SparseSetIndex, system::Resource};
+pub use bevy_ecs_macros::Component;
 use std::{
     alloc::Layout,
     any::{Any, TypeId},
@@ -13,7 +14,7 @@ use thiserror::Error;
 /// 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` automatically implements `Component`.
+/// Any type that is `Send + Sync + 'static` can implement `Component` using `#[derive(Component)]`.
 ///
 /// Components are added with new entities using [`Commands::spawn`](crate::system::Commands::spawn),
 /// or to existing entities with [`EntityCommands::insert`](crate::system::EntityCommands::insert),
@@ -24,7 +25,26 @@ use thiserror::Error;
 ///
 /// Components can be grouped together into a [`Bundle`](crate::bundle::Bundle).
 pub trait Component: Send + Sync + 'static {}
-impl<T: Send + Sync + 'static> Component for T {}
+
+// ECS dependencies cannot derive Component, so we must implement it manually for relevant structs.
+impl<T> Component for bevy_tasks::Task<T> where Self: Send + Sync + 'static {}
+
+// For our own convinience, let's implement Component for primitives in tests.
+// It will eventually be removed, once tests are not using them anymore.
+// Consider those impls deprecated.
+#[cfg(test)]
+mod private_test_component_impls {
+    use super::Component;
+    impl Component for &'static str {}
+    impl Component for usize {}
+    impl Component for i32 {}
+    impl Component for u32 {}
+    impl Component for u64 {}
+    impl Component for f32 {}
+    impl Component for f64 {}
+    impl Component for u8 {}
+    impl Component for bool {}
+}
 
 #[derive(Debug, Copy, Clone, Eq, PartialEq)]
 pub enum StorageType {
@@ -262,7 +282,7 @@ impl Components {
     }
 
     #[inline]
-    pub fn get_or_insert_resource_id<T: Component>(&mut self) -> ComponentId {
+    pub fn get_or_insert_resource_id<T: Resource>(&mut self) -> ComponentId {
         self.get_or_insert_resource_with(TypeId::of::<T>(), TypeInfo::of::<T>)
     }
 

crates/bevy_ecs/src/event.rs

@@ -1,8 +1,5 @@
-use crate as bevy_ecs;
-use crate::{
-    component::Component,
-    system::{Local, Res, ResMut, SystemParam},
-};
+use crate::system::{Local, Res, ResMut, SystemParam};
+use crate::{self as bevy_ecs, system::Resource};
 use bevy_utils::tracing::trace;
 use std::{
     fmt::{self},
@@ -151,18 +148,18 @@ fn map_instance_event<T>(event_instance: &EventInstance<T>) -> &T {
 
 /// Reads events of type `T` in order and tracks which events have already been read.
 #[derive(SystemParam)]
-pub struct EventReader<'a, T: Component> {
+pub struct EventReader<'a, T: Resource> {
     last_event_count: Local<'a, (usize, PhantomData<T>)>,
     events: Res<'a, Events<T>>,
 }
 
 /// Sends events of type `T`.
 #[derive(SystemParam)]
-pub struct EventWriter<'a, T: Component> {
+pub struct EventWriter<'a, T: Resource> {
     events: ResMut<'a, Events<T>>,
 }
 
-impl<'a, T: Component> EventWriter<'a, T> {
+impl<'a, T: Resource> EventWriter<'a, T> {
     pub fn send(&mut self, event: T) {
         self.events.send(event);
     }
@@ -252,7 +249,7 @@ fn internal_event_reader<'a, T>(
     }
 }
 
-impl<'a, T: Component> EventReader<'a, T> {
+impl<'a, T: Resource> EventReader<'a, T> {
     /// Iterates over the events this EventReader has not seen yet. This updates the EventReader's
     /// event counter, which means subsequent event reads will not include events that happened
     /// before now.
@@ -269,7 +266,7 @@ impl<'a, T: Component> EventReader<'a, T> {
     }
 }
 
-impl<T: Component> Events<T> {
+impl<T: Resource> Events<T> {
     /// "Sends" an `event` by writing it to the current event buffer. [EventReader]s can then read
     /// the event.
     pub fn send(&mut self, event: T) {

crates/bevy_ecs/src/lib.rs

@@ -20,6 +20,7 @@ pub mod prelude {
     pub use crate::{
         bundle::Bundle,
         change_detection::DetectChanges,
+        component::Component,
         entity::Entity,
         event::{EventReader, EventWriter},
         query::{Added, ChangeTrackers, Changed, Or, QueryState, With, WithBundle, Without},
@@ -58,12 +59,14 @@ mod tests {
         },
     };
 
-    #[derive(Debug, PartialEq, Eq)]
+    #[derive(Component, Debug, PartialEq, Eq)]
     struct A(usize);
+    #[derive(Component)]
     struct B(usize);
+    #[derive(Component)]
     struct C;
 
-    #[derive(Clone, Debug)]
+    #[derive(Component, Clone, Debug)]
     struct DropCk(Arc<AtomicUsize>);
     impl DropCk {
         fn new_pair() -> (Self, Arc<AtomicUsize>) {
@@ -760,7 +763,7 @@ mod tests {
         let e1 = world.spawn().insert_bundle((A(0), B(0))).id();
         let e2 = world.spawn().insert_bundle((A(0), B(0))).id();
         let e3 = world.spawn().insert_bundle((A(0), B(0))).id();
-        world.spawn().insert_bundle((A(0), B));
+        world.spawn().insert_bundle((A(0), B(0)));
 
         world.clear_trackers();
 
@@ -788,7 +791,7 @@ mod tests {
         assert_eq!(get_filtered::<Changed<A>>(&mut world), vec![e3, e1], "changed entities list should not change (although the order will due to archetype moves)");
 
         // spawning a new A entity should not change existing changed state
-        world.entity_mut(e1).insert_bundle((A(0), B));
+        world.entity_mut(e1).insert_bundle((A(0), B(0)));
         assert_eq!(
             get_filtered::<Changed<A>>(&mut world),
             vec![e3, e1],