From f69f79b0090be87449ec87674745685ad57e892d Mon Sep 17 00:00:00 2001
From: Frizi <frizi09@gmail.com>
Date: Tue, 25 May 2021 12:40:53 +0200
Subject: [PATCH 01/22] implement and require derive(Component)

---
 crates/bevy_app/src/app_builder.rs            |  12 +-
 crates/bevy_asset/src/handle.rs               |   4 +-
 crates/bevy_asset/src/loader.rs               |  13 +--
 crates/bevy_core/src/label.rs                 |   3 +-
 crates/bevy_core/src/name.rs                  |   4 +-
 crates/bevy_core/src/time/stopwatch.rs        |   4 +-
 crates/bevy_core/src/time/timer.rs            |   4 +-
 crates/bevy_ecs/macros/src/component.rs       |  20 ++++
 crates/bevy_ecs/macros/src/lib.rs             |   9 +-
 crates/bevy_ecs/src/change_detection.rs       |  10 +-
 crates/bevy_ecs/src/component/mod.rs          |  28 ++++-
 crates/bevy_ecs/src/event.rs                  |  17 ++-
 crates/bevy_ecs/src/lib.rs                    |  11 +-
 crates/bevy_ecs/src/query/fetch.rs            |   6 +-
 crates/bevy_ecs/src/query/filter.rs           |  34 +++---
 crates/bevy_ecs/src/query/mod.rs              |   7 +-
 crates/bevy_ecs/src/schedule/stage.rs         |   3 +
 crates/bevy_ecs/src/schedule/state.rs         |  19 ++-
 crates/bevy_ecs/src/schedule/system_set.rs    |  16 +--
 crates/bevy_ecs/src/system/commands.rs        |  60 +++++++---
 crates/bevy_ecs/src/system/mod.rs             |  10 +-
 crates/bevy_ecs/src/system/query.rs           |  23 +++-
 crates/bevy_ecs/src/system/system_param.rs    |  77 ++++++------
 crates/bevy_ecs/src/world/mod.rs              | 110 ++++++++++++------
 crates/bevy_ecs/src/world/world_cell.rs       |   6 +-
 crates/bevy_pbr/src/light.rs                  |   6 +-
 crates/bevy_pbr/src/material.rs               |   3 +-
 .../bevy_render/src/camera/active_cameras.rs  |   3 +-
 crates/bevy_render/src/camera/camera.rs       |   2 +-
 crates/bevy_render/src/camera/projection.rs   |   6 +-
 .../src/camera/visible_entities.rs            |   8 +-
 crates/bevy_render/src/draw.rs                |   7 +-
 .../src/pipeline/render_pipelines.rs          |   3 +-
 crates/bevy_render/src/render_graph/base.rs   |   4 +-
 .../nodes/render_resources_node.rs            |   5 +-
 crates/bevy_render/src/shader/shader_defs.rs  |   3 +-
 crates/bevy_render/src/wireframe/mod.rs       |   3 +-
 crates/bevy_sprite/src/sprite.rs              |   3 +-
 crates/bevy_sprite/src/texture_atlas.rs       |   3 +-
 crates/bevy_text/src/text.rs                  |   5 +-
 .../bevy_transform/src/components/children.rs |   3 +-
 .../src/components/global_transform.rs        |   4 +-
 .../bevy_transform/src/components/parent.rs   |   5 +-
 .../src/components/transform.rs               |   4 +-
 .../src/hierarchy/child_builder.rs            |  16 ++-
 .../bevy_transform/src/hierarchy/hierarchy.rs |  37 +++---
 crates/bevy_ui/src/focus.rs                   |   5 +-
 crates/bevy_ui/src/ui_node.rs                 |   8 +-
 crates/bevy_ui/src/update.rs                  |  46 ++++----
 crates/bevy_ui/src/widget/button.rs           |   4 +-
 crates/bevy_ui/src/widget/image.rs            |   3 +-
 examples/2d/contributors.rs                   |   4 +
 examples/2d/many_sprites.rs                   |   2 +
 examples/2d/text2d.rs                         |   3 +
 examples/3d/load_gltf.rs                      |   1 +
 examples/3d/parenting.rs                      |   1 +
 examples/3d/render_to_texture.rs              |   3 +
 examples/3d/update_gltf_scene.rs              |   1 +
 examples/3d/z_sort_debug.rs                   |   1 +
 examples/ecs/change_detection.rs              |   2 +-
 examples/ecs/ecs_guide.rs                     |   2 +
 examples/ecs/iter_combinations.rs             |   6 +-
 examples/ecs/parallel_query.rs                |   1 +
 examples/ecs/query_bundle.rs                  |   4 +-
 examples/ecs/removal_detection.rs             |   1 +
 examples/ecs/system_param.rs                  |   2 +
 examples/game/breakout.rs                     |  11 +-
 examples/scene/scene.rs                       |   4 +-
 examples/shader/animate_shader.rs             |   2 +-
 examples/shader/array_texture.rs              |   2 +-
 examples/tools/bevymark.rs                    |   1 +
 examples/ui/text.rs                           |   2 +
 examples/ui/text_debug.rs                     |   1 +
 tests/how_to_test_systems.rs                  |   2 +-
 74 files changed, 489 insertions(+), 279 deletions(-)
 create mode 100644 crates/bevy_ecs/macros/src/component.rs

diff --git a/crates/bevy_app/src/app_builder.rs b/crates/bevy_app/src/app_builder.rs
index 58a2dbdd87c22..58bf336223d06 100644
--- a/crates/bevy_app/src/app_builder.rs
+++ b/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
diff --git a/crates/bevy_asset/src/handle.rs b/crates/bevy_asset/src/handle.rs
index ae2bb45c0837c..1a606c1a62c80 100644
--- a/crates/bevy_asset/src/handle.rs
+++ b/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
diff --git a/crates/bevy_asset/src/loader.rs b/crates/bevy_asset/src/loader.rs
index 825eab38a459e..2eb85782205e4 100644
--- a/crates/bevy_asset/src/loader.rs
+++ b/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,7 +143,7 @@ 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,
@@ -154,12 +151,12 @@ pub struct AssetResult<T: Component> {
 
 /// 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 }
diff --git a/crates/bevy_core/src/label.rs b/crates/bevy_core/src/label.rs
index ce7b676eb641b..ef6872045b127 100644
--- a/crates/bevy_core/src/label.rs
+++ b/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>>,
diff --git a/crates/bevy_core/src/name.rs b/crates/bevy_core/src/name.rs
index 7390fd8b18688..593c7ae202baf 100644
--- a/crates/bevy_core/src/name.rs
+++ b/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
diff --git a/crates/bevy_core/src/time/stopwatch.rs b/crates/bevy_core/src/time/stopwatch.rs
index 8aa1e974c9647..d03da20824f39 100644
--- a/crates/bevy_core/src/time/stopwatch.rs
+++ b/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,
diff --git a/crates/bevy_core/src/time/timer.rs b/crates/bevy_core/src/time/timer.rs
index 290d73e7c197f..041f712b818e2 100644
--- a/crates/bevy_core/src/time/timer.rs
+++ b/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,
diff --git a/crates/bevy_ecs/macros/src/component.rs b/crates/bevy_ecs/macros/src/component.rs
new file mode 100644
index 0000000000000..e0aae6e6b7f83
--- /dev/null
+++ b/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 {}
+    })
+}
diff --git a/crates/bevy_ecs/macros/src/lib.rs b/crates/bevy_ecs/macros/src/lib.rs
index 27383ff71ee55..2de0b9e22762b 100644
--- a/crates/bevy_ecs/macros/src/lib.rs
+++ b/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};
@@ -475,6 +477,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)
+}
diff --git a/crates/bevy_ecs/src/change_detection.rs b/crates/bevy_ecs/src/change_detection.rs
index bc420879f2db4..087ead17cb782 100644
--- a/crates/bevy_ecs/src/change_detection.rs
+++ b/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> {
diff --git a/crates/bevy_ecs/src/component/mod.rs b/crates/bevy_ecs/src/component/mod.rs
index 4a392bbe3a898..d3cd8c38c56b3 100644
--- a/crates/bevy_ecs/src/component/mod.rs
+++ b/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>)
     }
 
diff --git a/crates/bevy_ecs/src/event.rs b/crates/bevy_ecs/src/event.rs
index 11de10b34d084..4ab5cdd846072 100644
--- a/crates/bevy_ecs/src/event.rs
+++ b/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) {
diff --git a/crates/bevy_ecs/src/lib.rs b/crates/bevy_ecs/src/lib.rs
index a6fdbced0894d..d20deeeb29c14 100644
--- a/crates/bevy_ecs/src/lib.rs
+++ b/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],
diff --git a/crates/bevy_ecs/src/query/fetch.rs b/crates/bevy_ecs/src/query/fetch.rs
index 2764f897310f2..39d411e332b9c 100644
--- a/crates/bevy_ecs/src/query/fetch.rs
+++ b/crates/bevy_ecs/src/query/fetch.rs
@@ -691,12 +691,14 @@ impl<'w, T: Fetch<'w>> Fetch<'w> for OptionFetch<T> {
 /// # Examples
 ///
 /// ```
-/// # use bevy_ecs::system::Query;
+/// # use bevy_ecs::component::Component;
 /// # use bevy_ecs::query::ChangeTrackers;
 /// # use bevy_ecs::system::IntoSystem;
+/// # use bevy_ecs::system::Query;
 /// #
-/// # #[derive(Debug)]
+/// # #[derive(Component, Debug)]
 /// # struct Name {};
+/// # #[derive(Component)]
 /// # struct Transform {};
 /// #
 /// fn print_moving_objects_system(query: Query<(&Name, ChangeTrackers<Transform>)>) {
diff --git a/crates/bevy_ecs/src/query/filter.rs b/crates/bevy_ecs/src/query/filter.rs
index cd3d2c9c801c9..05f0befd45134 100644
--- a/crates/bevy_ecs/src/query/filter.rs
+++ b/crates/bevy_ecs/src/query/filter.rs
@@ -51,12 +51,14 @@ where
 /// # Examples
 ///
 /// ```
-/// # use bevy_ecs::system::Query;
+/// # use bevy_ecs::component::Component;
 /// # use bevy_ecs::query::With;
 /// # use bevy_ecs::system::IntoSystem;
+/// # use bevy_ecs::system::Query;
 /// #
-/// # #[derive(Debug)]
-/// # struct IsBeautiful {};
+/// # #[derive(Component)]
+/// # struct IsBeautiful;
+/// # #[derive(Component)]
 /// # struct Name { name: &'static str };
 /// #
 /// fn compliment_entity_system(query: Query<&Name, With<IsBeautiful>>) {
@@ -170,12 +172,14 @@ impl<'a, T: Component> Fetch<'a> for WithFetch<T> {
 /// # Examples
 ///
 /// ```
-/// # use bevy_ecs::system::Query;
+/// # use bevy_ecs::component::Component;
 /// # use bevy_ecs::query::Without;
 /// # use bevy_ecs::system::IntoSystem;
+/// # use bevy_ecs::system::Query;
 /// #
-/// # #[derive(Debug)]
+/// # #[derive(Component)]
 /// # struct Permit;
+/// # #[derive(Component)]
 /// # struct Name { name: &'static str };
 /// #
 /// fn no_permit_system(query: Query<&Name, Without<Permit>>) {
@@ -393,14 +397,16 @@ impl<'a, T: Bundle> Fetch<'a> for WithBundleFetch<T> {
 /// # Examples
 ///
 /// ```
+/// # use bevy_ecs::component::Component;
 /// # use bevy_ecs::entity::Entity;
-/// # use bevy_ecs::system::Query;
-/// # use bevy_ecs::system::IntoSystem;
 /// # use bevy_ecs::query::Changed;
 /// # use bevy_ecs::query::Or;
+/// # use bevy_ecs::system::IntoSystem;
+/// # use bevy_ecs::system::Query;
 /// #
-/// # #[derive(Debug)]
+/// # #[derive(Component, Debug)]
 /// # struct Color {};
+/// # #[derive(Component)]
 /// # struct Style {};
 /// #
 /// fn print_cool_entity_system(query: Query<Entity, Or<(Changed<Color>, Changed<Style>)>>) {
@@ -697,13 +703,13 @@ impl_tick_filter!(
     /// # Examples
     ///
     /// ```
+    /// # use bevy_ecs::component::Component;
+    /// # use bevy_ecs::query::Added;
     /// # use bevy_ecs::system::IntoSystem;
     /// # use bevy_ecs::system::Query;
-    /// # use bevy_ecs::query::Added;
     /// #
-    /// # #[derive(Debug)]
+    /// # #[derive(Component, Debug)]
     /// # struct Name {};
-    /// # struct Transform {};
     ///
     /// fn print_add_name_component(query: Query<&Name, Added<Name>>) {
     ///     for name in query.iter() {
@@ -738,12 +744,14 @@ impl_tick_filter!(
     /// # Examples
     ///
     /// ```
+    /// # use bevy_ecs::component::Component;
+    /// # use bevy_ecs::query::Changed;
     /// # use bevy_ecs::system::IntoSystem;
     /// # use bevy_ecs::system::Query;
-    /// # use bevy_ecs::query::Changed;
     /// #
-    /// # #[derive(Debug)]
+    /// # #[derive(Component, Debug)]
     /// # struct Name {};
+    /// # #[derive(Component)]
     /// # struct Transform {};
     ///
     /// fn print_moving_objects_system(query: Query<&Name, Changed<Transform>>) {
diff --git a/crates/bevy_ecs/src/query/mod.rs b/crates/bevy_ecs/src/query/mod.rs
index 99e140846073c..bd8f8313953eb 100644
--- a/crates/bevy_ecs/src/query/mod.rs
+++ b/crates/bevy_ecs/src/query/mod.rs
@@ -13,13 +13,14 @@ pub use state::*;
 #[cfg(test)]
 mod tests {
     use crate::{
-        component::{ComponentDescriptor, StorageType},
+        self as bevy_ecs,
+        component::{Component, ComponentDescriptor, StorageType},
         world::World,
     };
 
-    #[derive(Debug, Eq, PartialEq)]
+    #[derive(Component, Debug, Eq, PartialEq)]
     struct A(usize);
-    #[derive(Debug, Eq, PartialEq)]
+    #[derive(Component, Debug, Eq, PartialEq)]
     struct B(usize);
 
     #[test]
diff --git a/crates/bevy_ecs/src/schedule/stage.rs b/crates/bevy_ecs/src/schedule/stage.rs
index a92ffe7d67475..47a5fdab2f8a3 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -2060,6 +2060,9 @@ mod tests {
 
     #[test]
     fn change_query_wrapover() {
+        use crate::{self as bevy_ecs, component::Component};
+
+        #[derive(Component)]
         struct C;
         let mut world = World::new();
 
diff --git a/crates/bevy_ecs/src/schedule/state.rs b/crates/bevy_ecs/src/schedule/state.rs
index d80fb7970dd46..b90f128bc2d64 100644
--- a/crates/bevy_ecs/src/schedule/state.rs
+++ b/crates/bevy_ecs/src/schedule/state.rs
@@ -1,10 +1,9 @@
 use crate::{
-    component::Component,
     schedule::{
         RunCriteriaDescriptor, RunCriteriaDescriptorCoercion, RunCriteriaLabel, ShouldRun,
         SystemSet,
     },
-    system::{In, IntoChainSystem, IntoSystem, Local, Res, ResMut},
+    system::{In, IntoChainSystem, IntoSystem, Local, Res, ResMut, Resource},
 };
 use std::{any::TypeId, fmt::Debug, hash::Hash};
 use thiserror::Error;
@@ -17,7 +16,7 @@ use thiserror::Error;
 /// * Set replaces the active state with a new one
 /// * Replace unwinds the state stack, and replaces the entire stack with a single new state
 #[derive(Debug)]
-pub struct State<T: Component + Clone + Eq> {
+pub struct State<T: Resource + Clone + Eq> {
     transition: Option<StateTransition<T>>,
     stack: Vec<T>,
     scheduled: Option<ScheduledOperation<T>>,
@@ -25,7 +24,7 @@ pub struct State<T: Component + Clone + Eq> {
 }
 
 #[derive(Debug)]
-enum StateTransition<T: Component + Clone + Eq> {
+enum StateTransition<T: Resource + Clone + Eq> {
     PreStartup,
     Startup,
     // The parameter order is always (leaving, entering)
@@ -37,7 +36,7 @@ enum StateTransition<T: Component + Clone + Eq> {
 }
 
 #[derive(Debug)]
-enum ScheduledOperation<T: Component + Clone + Eq> {
+enum ScheduledOperation<T: Resource + Clone + Eq> {
     Set(T),
     Replace(T),
     Pop,
@@ -58,7 +57,7 @@ enum StateCallback {
 impl StateCallback {
     fn into_label<T>(self, state: T) -> StateRunCriteriaLabel<T>
     where
-        T: Component + Debug + Clone + Eq + Hash,
+        T: Resource + Debug + Clone + Eq + Hash,
     {
         StateRunCriteriaLabel(state, self)
     }
@@ -68,7 +67,7 @@ impl StateCallback {
 struct StateRunCriteriaLabel<T>(T, StateCallback);
 impl<T> RunCriteriaLabel for StateRunCriteriaLabel<T>
 where
-    T: Component + Debug + Clone + Eq + Hash,
+    T: Resource + Debug + Clone + Eq + Hash,
 {
     fn dyn_clone(&self) -> Box<dyn RunCriteriaLabel> {
         Box::new(self.clone())
@@ -91,7 +90,7 @@ impl DriverLabel {
 
 impl<T> State<T>
 where
-    T: Component + Debug + Clone + Eq + Hash,
+    T: Resource + Debug + Clone + Eq + Hash,
 {
     pub fn on_update(s: T) -> RunCriteriaDescriptor {
         (|state: Res<State<T>>, pred: Local<Option<T>>| {
@@ -394,7 +393,7 @@ pub enum StateError {
     StackEmpty,
 }
 
-fn should_run_adapter<T: Component + Clone + Eq>(
+fn should_run_adapter<T: Resource + Clone + Eq>(
     In(cmp_result): In<bool>,
     state: Res<State<T>>,
 ) -> ShouldRun {
@@ -408,7 +407,7 @@ fn should_run_adapter<T: Component + Clone + Eq>(
     }
 }
 
-fn state_cleaner<T: Component + Clone + Eq>(
+fn state_cleaner<T: Resource + Clone + Eq>(
     mut state: ResMut<State<T>>,
     mut prep_exit: Local<bool>,
 ) -> ShouldRun {
diff --git a/crates/bevy_ecs/src/schedule/system_set.rs b/crates/bevy_ecs/src/schedule/system_set.rs
index f6e058413d8ef..6748b34775d83 100644
--- a/crates/bevy_ecs/src/schedule/system_set.rs
+++ b/crates/bevy_ecs/src/schedule/system_set.rs
@@ -1,9 +1,9 @@
 use crate::{
-    component::Component,
     schedule::{
         AmbiguitySetLabel, BoxedAmbiguitySetLabel, BoxedSystemLabel, IntoRunCriteria,
         RunCriteriaDescriptorOrLabel, State, SystemDescriptor, SystemLabel,
     },
+    system::Resource,
 };
 use std::{fmt::Debug, hash::Hash};
 
@@ -37,49 +37,49 @@ impl SystemSet {
 
     pub fn on_update<T>(s: T) -> SystemSet
     where
-        T: Component + Debug + Clone + Eq + Hash,
+        T: Resource + Debug + Clone + Eq + Hash,
     {
         Self::new().with_run_criteria(State::<T>::on_update(s))
     }
 
     pub fn on_inactive_update<T>(s: T) -> SystemSet
     where
-        T: Component + Debug + Clone + Eq + Hash,
+        T: Resource + Debug + Clone + Eq + Hash,
     {
         Self::new().with_run_criteria(State::<T>::on_inactive_update(s))
     }
 
     pub fn on_in_stack_update<T>(s: T) -> SystemSet
     where
-        T: Component + Debug + Clone + Eq + Hash,
+        T: Resource + Debug + Clone + Eq + Hash,
     {
         Self::new().with_run_criteria(State::<T>::on_in_stack_update(s))
     }
 
     pub fn on_enter<T>(s: T) -> SystemSet
     where
-        T: Component + Debug + Clone + Eq + Hash,
+        T: Resource + Debug + Clone + Eq + Hash,
     {
         Self::new().with_run_criteria(State::<T>::on_enter(s))
     }
 
     pub fn on_exit<T>(s: T) -> SystemSet
     where
-        T: Component + Debug + Clone + Eq + Hash,
+        T: Resource + Debug + Clone + Eq + Hash,
     {
         Self::new().with_run_criteria(State::<T>::on_exit(s))
     }
 
     pub fn on_pause<T>(s: T) -> SystemSet
     where
-        T: Component + Debug + Clone + Eq + Hash,
+        T: Resource + Debug + Clone + Eq + Hash,
     {
         Self::new().with_run_criteria(State::<T>::on_pause(s))
     }
 
     pub fn on_resume<T>(s: T) -> SystemSet
     where
-        T: Component + Debug + Clone + Eq + Hash,
+        T: Resource + Debug + Clone + Eq + Hash,
     {
         Self::new().with_run_criteria(State::<T>::on_resume(s))
     }
diff --git a/crates/bevy_ecs/src/system/commands.rs b/crates/bevy_ecs/src/system/commands.rs
index 90adfb8dc510c..d62c0da5b47ab 100644
--- a/crates/bevy_ecs/src/system/commands.rs
+++ b/crates/bevy_ecs/src/system/commands.rs
@@ -7,6 +7,8 @@ use crate::{
 use bevy_utils::tracing::debug;
 use std::marker::PhantomData;
 
+use super::Resource;
+
 /// A [`World`] mutation.
 pub trait Command: Send + Sync + 'static {
     fn write(self: Box<Self>, world: &mut World);
@@ -63,6 +65,13 @@ impl<'a> Commands<'a> {
     /// ```
     /// use bevy_ecs::prelude::*;
     ///
+    /// #[derive(Component)]
+    /// struct Label(&'static str);
+    /// #[derive(Component)]
+    /// struct Strength(u32);
+    /// #[derive(Component)]
+    /// struct Agility(u32);
+    ///
     /// fn example_system(mut commands: Commands) {
     ///     // Create a new empty entity and retrieve its id.
     ///     let empty_entity = commands.spawn().id();
@@ -70,9 +79,9 @@ impl<'a> Commands<'a> {
     ///     // Create another empty entity, then add some component to it
     ///     commands.spawn()
     ///         // adds a new component bundle to the entity
-    ///         .insert_bundle((1usize, 2u32))
+    ///         .insert_bundle((Strength(1), Agility(2)))
     ///         // adds a single component to the entity
-    ///         .insert("hello world");
+    ///         .insert(Label("hello world"));
     /// }
     /// # example_system.system();
     /// ```
@@ -98,8 +107,16 @@ impl<'a> Commands<'a> {
     /// ```
     /// use bevy_ecs::prelude::*;
     ///
+    /// #[derive(Component)]
     /// struct Component1;
+    /// #[derive(Component)]
     /// struct Component2;
+    /// #[derive(Component)]
+    /// struct Label(&'static str);
+    /// #[derive(Component)]
+    /// struct Strength(u32);
+    /// #[derive(Component)]
+    /// struct Agility(u32);
     ///
     /// #[derive(Bundle)]
     /// struct ExampleBundle {
@@ -118,9 +135,9 @@ impl<'a> Commands<'a> {
     ///         // Create a new entity with two components using a "tuple bundle".
     ///         .spawn_bundle((Component1, Component2))
     ///         // spawn_bundle returns a builder, so you can insert more bundles like this:
-    ///         .insert_bundle((1usize, 2u32))
+    ///         .insert_bundle((Strength(1), Agility(2)))
     ///         // or insert single components like this:
-    ///         .insert("hello world");
+    ///         .insert(Label("hello world"));
     /// }
     /// # example_system.system();
     /// ```
@@ -137,15 +154,22 @@ impl<'a> Commands<'a> {
     /// ```
     /// use bevy_ecs::prelude::*;
     ///
+    /// #[derive(Component)]
+    /// struct Label(&'static str);
+    /// #[derive(Component)]
+    /// struct Strength(u32);
+    /// #[derive(Component)]
+    /// struct Agility(u32);
+
     /// fn example_system(mut commands: Commands) {
     ///     // Create a new, empty entity
     ///     let entity = commands.spawn().id();
     ///
     ///     commands.entity(entity)
     ///         // adds a new component bundle to the entity
-    ///         .insert_bundle((1usize, 2u32))
+    ///         .insert_bundle((Strength(1), Agility(2)))
     ///         // adds a single component to the entity
-    ///         .insert("hello world");
+    ///         .insert(Label("hello world"));
     /// }
     /// # example_system.system();
     /// ```
@@ -167,12 +191,12 @@ impl<'a> Commands<'a> {
     }
 
     /// See [`World::insert_resource`].
-    pub fn insert_resource<T: Component>(&mut self, resource: T) {
+    pub fn insert_resource<T: Resource>(&mut self, resource: T) {
         self.queue.push(InsertResource { resource })
     }
 
     /// Queue a resource removal.
-    pub fn remove_resource<T: Component>(&mut self) {
+    pub fn remove_resource<T: Resource>(&mut self) {
         self.queue.push(RemoveResource::<T> {
             phantom: PhantomData,
         });
@@ -223,8 +247,11 @@ impl<'a, 'b> EntityCommands<'a, 'b> {
     /// ```
     /// use bevy_ecs::prelude::*;
     ///
+    /// #[derive(Component)]
     /// struct Component1;
+    /// #[derive(Component)]
     /// struct Component2;
+
     ///
     /// fn example_system(mut commands: Commands) {
     ///     // Create a new entity with `Component1` and `Component2`
@@ -393,21 +420,21 @@ where
     }
 }
 
-pub struct InsertResource<T: Component> {
+pub struct InsertResource<T: Resource> {
     pub resource: T,
 }
 
-impl<T: Component> Command for InsertResource<T> {
+impl<T: Resource> Command for InsertResource<T> {
     fn write(self: Box<Self>, world: &mut World) {
         world.insert_resource(self.resource);
     }
 }
 
-pub struct RemoveResource<T: Component> {
+pub struct RemoveResource<T: Resource> {
     pub phantom: PhantomData<T>,
 }
 
-impl<T: Component> Command for RemoveResource<T> {
+impl<T: Resource> Command for RemoveResource<T> {
     fn write(self: Box<Self>, world: &mut World) {
         world.remove_resource::<T>();
     }
@@ -417,7 +444,8 @@ impl<T: Component> Command for RemoveResource<T> {
 #[allow(clippy::float_cmp, clippy::approx_constant)]
 mod tests {
     use crate::{
-        component::{ComponentDescriptor, StorageType},
+        self as bevy_ecs,
+        component::{Component, ComponentDescriptor, StorageType},
         system::{CommandQueue, Commands},
         world::World,
     };
@@ -426,7 +454,10 @@ mod tests {
         Arc,
     };
 
-    #[derive(Clone, Debug)]
+    #[derive(Component)]
+    struct DenseDropCk(DropCk);
+
+    #[derive(Component)]
     struct DropCk(Arc<AtomicUsize>);
     impl DropCk {
         fn new_pair() -> (Self, Arc<AtomicUsize>) {
@@ -475,7 +506,6 @@ mod tests {
     fn remove_components() {
         let mut world = World::default();
 
-        struct DenseDropCk(DropCk);
         world
             .register_component(ComponentDescriptor::new::<DropCk>(StorageType::SparseSet))
             .unwrap();
diff --git a/crates/bevy_ecs/src/system/mod.rs b/crates/bevy_ecs/src/system/mod.rs
index 2dc7716a54b72..c5b40466fecc2 100644
--- a/crates/bevy_ecs/src/system/mod.rs
+++ b/crates/bevy_ecs/src/system/mod.rs
@@ -20,9 +20,10 @@ mod tests {
     use std::any::TypeId;
 
     use crate::{
+        self as bevy_ecs,
         archetype::Archetypes,
         bundle::Bundles,
-        component::Components,
+        component::{Component, Components},
         entity::{Entities, Entity},
         query::{Added, Changed, Or, With, Without},
         schedule::{Schedule, Stage, SystemStage},
@@ -33,12 +34,17 @@ mod tests {
         world::{FromWorld, World},
     };
 
-    #[derive(Debug, Eq, PartialEq, Default)]
+    #[derive(Component, Debug, Eq, PartialEq, Default)]
     struct A;
+    #[derive(Component)]
     struct B;
+    #[derive(Component)]
     struct C;
+    #[derive(Component)]
     struct D;
+    #[derive(Component)]
     struct E;
+    #[derive(Component)]
     struct F;
 
     #[test]
diff --git a/crates/bevy_ecs/src/system/query.rs b/crates/bevy_ecs/src/system/query.rs
index 6173889eeef33..af9ea0871896b 100644
--- a/crates/bevy_ecs/src/system/query.rs
+++ b/crates/bevy_ecs/src/system/query.rs
@@ -27,8 +27,10 @@ use thiserror::Error;
 /// functions which return a [`QueryIter`] to iterate over:
 ///
 /// ```
+/// # use bevy_ecs::component::Component;
 /// # use bevy_ecs::system::IntoSystem;
 /// # use bevy_ecs::system::Query;
+/// #[derive(Component)]
 /// struct UnitHealth(pub u32);
 /// fn system(query: Query<&UnitHealth>) {
 ///     for UnitHealth(health) in query.iter() {
@@ -46,15 +48,19 @@ use thiserror::Error;
 /// component.
 ///
 /// ```
+/// # use bevy_ecs::component::Component;
 /// # use bevy_ecs::system::IntoSystem;
 /// # use bevy_ecs::system::Query;
-/// #[derive(Debug)]
+/// #[derive(Component, Debug)]
 /// enum Shape {
 ///     Circle,
 ///     Box,
 /// };
+/// #[derive(Component)]
 /// struct Color(pub String);
+/// #[derive(Component)]
 /// struct Size(pub u32);
+///
 /// fn system(mut query: Query<(&Shape, &Color, &mut Size)>) {
 ///     for (shape, color, mut size) in query.iter_mut() {
 ///         *size = Size(1);
@@ -75,11 +81,15 @@ use thiserror::Error;
 /// it requests. Let's look at an example on how to use this filter.
 ///
 /// ```
+/// # use bevy_ecs::component::Component;
+/// # use bevy_ecs::query::With;
 /// # use bevy_ecs::system::IntoSystem;
 /// # use bevy_ecs::system::Query;
-/// # use bevy_ecs::query::With;
+/// #[derive(Component)]
 /// struct Person(String);
+/// #[derive(Component)]
 /// struct IsTallEnough;
+///
 /// fn system(query: Query<&Person, With<IsTallEnough>>) {
 ///     for person in query.iter() {
 ///         println!("{} is tall enough!", person.0);
@@ -198,8 +208,9 @@ where
     /// In order to iterate it, use `fetch_next` method with `while let Some(..)` loop pattern.
     ///
     /// ```
-    /// # struct A;
     /// # use bevy_ecs::prelude::*;
+    /// #[derive(Component)]
+    /// # struct A;
     /// # fn some_system(mut query: Query<&mut A>) {
     /// // iterate using `fetch_next` in while loop
     /// let mut combinations = query.iter_combinations_mut();
@@ -491,9 +502,11 @@ where
     /// # Examples
     ///
     /// ```
-    ///  # use bevy_ecs::system::{Query, QuerySingleError};
-    ///  # use bevy_ecs::prelude::IntoSystem;
+    ///  # use bevy_ecs::system::{QuerySingleError};
+    ///  # use bevy_ecs::prelude::*;
+    /// #[derive(Component)]
     /// struct PlayerScore(i32);
+    ///
     /// fn player_scoring_system(query: Query<&PlayerScore>) {
     ///     match query.single() {
     ///         Ok(PlayerScore(score)) => {
diff --git a/crates/bevy_ecs/src/system/system_param.rs b/crates/bevy_ecs/src/system/system_param.rs
index 95dd4cee1bc83..8f1613c4406f2 100644
--- a/crates/bevy_ecs/src/system/system_param.rs
+++ b/crates/bevy_ecs/src/system/system_param.rs
@@ -189,6 +189,9 @@ pub struct QuerySetState<T>(T);
 
 impl_query_set!();
 
+pub trait Resource: Send + Sync + 'static {}
+impl<T> Resource for T where T: Send + Sync + 'static {}
+
 /// Shared borrow of a resource.
 ///
 /// # Panics
@@ -196,7 +199,7 @@ impl_query_set!();
 /// Panics when used as a [`SystemParameter`](SystemParam) if the resource does not exist.
 ///
 /// Use `Option<Res<T>>` instead if the resource might not always exist.
-pub struct Res<'w, T: Component> {
+pub struct Res<'w, T: Resource> {
     value: &'w T,
     ticks: &'w ComponentTicks,
     last_change_tick: u32,
@@ -204,9 +207,9 @@ pub struct Res<'w, T: Component> {
 }
 
 // SAFE: Res only reads a single World resource
-unsafe impl<T: Component> ReadOnlySystemParamFetch for ResState<T> {}
+unsafe impl<T: Resource> ReadOnlySystemParamFetch for ResState<T> {}
 
-impl<'w, T: Component> Debug for Res<'w, T>
+impl<'w, T: Resource> Debug for Res<'w, T>
 where
     T: Debug,
 {
@@ -215,7 +218,7 @@ where
     }
 }
 
-impl<'w, T: Component> Res<'w, T> {
+impl<'w, T: Resource> Res<'w, T> {
     /// Returns true if (and only if) this resource been added since the last execution of this
     /// system.
     pub fn is_added(&self) -> bool {
@@ -230,7 +233,7 @@ impl<'w, T: Component> Res<'w, T> {
     }
 }
 
-impl<'w, T: Component> Deref for Res<'w, T> {
+impl<'w, T: Resource> Deref for Res<'w, T> {
     type Target = T;
 
     fn deref(&self) -> &Self::Target {
@@ -238,7 +241,7 @@ impl<'w, T: Component> Deref for Res<'w, T> {
     }
 }
 
-impl<'w, T: Component> AsRef<T> for Res<'w, T> {
+impl<'w, T: Resource> AsRef<T> for Res<'w, T> {
     #[inline]
     fn as_ref(&self) -> &T {
         self.deref()
@@ -251,13 +254,13 @@ pub struct ResState<T> {
     marker: PhantomData<T>,
 }
 
-impl<'a, T: Component> SystemParam for Res<'a, T> {
+impl<'a, T: Resource> SystemParam for Res<'a, T> {
     type Fetch = ResState<T>;
 }
 
 // SAFE: Res ComponentId and ArchetypeComponentId access is applied to SystemMeta. If this Res
 // conflicts with any prior access, a panic will occur.
-unsafe impl<T: Component> SystemParamState for ResState<T> {
+unsafe impl<T: Resource> SystemParamState for ResState<T> {
     type Config = ();
 
     fn init(world: &mut World, system_meta: &mut SystemMeta, _config: Self::Config) -> Self {
@@ -286,7 +289,7 @@ unsafe impl<T: Component> SystemParamState for ResState<T> {
     fn default_config() {}
 }
 
-impl<'a, T: Component> SystemParamFetch<'a> for ResState<T> {
+impl<'a, T: Resource> SystemParamFetch<'a> for ResState<T> {
     type Item = Res<'a, T>;
 
     #[inline]
@@ -317,14 +320,14 @@ impl<'a, T: Component> SystemParamFetch<'a> for ResState<T> {
 /// The [`SystemParamState`] of `Option<Res<T>>`.
 pub struct OptionResState<T>(ResState<T>);
 
-impl<'a, T: Component> SystemParam for Option<Res<'a, T>> {
+impl<'a, T: Resource> SystemParam for Option<Res<'a, T>> {
     type Fetch = OptionResState<T>;
 }
 
 // SAFE: Only reads a single World resource
-unsafe impl<T: Component> ReadOnlySystemParamFetch for OptionResState<T> {}
+unsafe impl<T: Resource> ReadOnlySystemParamFetch for OptionResState<T> {}
 
-unsafe impl<T: Component> SystemParamState for OptionResState<T> {
+unsafe impl<T: Resource> SystemParamState for OptionResState<T> {
     type Config = ();
 
     fn init(world: &mut World, system_meta: &mut SystemMeta, _config: Self::Config) -> Self {
@@ -334,7 +337,7 @@ unsafe impl<T: Component> SystemParamState for OptionResState<T> {
     fn default_config() {}
 }
 
-impl<'a, T: Component> SystemParamFetch<'a> for OptionResState<T> {
+impl<'a, T: Resource> SystemParamFetch<'a> for OptionResState<T> {
     type Item = Option<Res<'a, T>>;
 
     #[inline]
@@ -361,13 +364,13 @@ pub struct ResMutState<T> {
     marker: PhantomData<T>,
 }
 
-impl<'a, T: Component> SystemParam for ResMut<'a, T> {
+impl<'a, T: Resource> SystemParam for ResMut<'a, T> {
     type Fetch = ResMutState<T>;
 }
 
 // SAFE: Res ComponentId and ArchetypeComponentId access is applied to SystemMeta. If this Res
 // conflicts with any prior access, a panic will occur.
-unsafe impl<T: Component> SystemParamState for ResMutState<T> {
+unsafe impl<T: Resource> SystemParamState for ResMutState<T> {
     type Config = ();
 
     fn init(world: &mut World, system_meta: &mut SystemMeta, _config: Self::Config) -> Self {
@@ -400,7 +403,7 @@ unsafe impl<T: Component> SystemParamState for ResMutState<T> {
     fn default_config() {}
 }
 
-impl<'a, T: Component> SystemParamFetch<'a> for ResMutState<T> {
+impl<'a, T: Resource> SystemParamFetch<'a> for ResMutState<T> {
     type Item = ResMut<'a, T>;
 
     #[inline]
@@ -433,11 +436,11 @@ impl<'a, T: Component> SystemParamFetch<'a> for ResMutState<T> {
 /// The [`SystemParamState`] of `Option<ResMut<T>>`.
 pub struct OptionResMutState<T>(ResMutState<T>);
 
-impl<'a, T: Component> SystemParam for Option<ResMut<'a, T>> {
+impl<'a, T: Resource> SystemParam for Option<ResMut<'a, T>> {
     type Fetch = OptionResMutState<T>;
 }
 
-unsafe impl<T: Component> SystemParamState for OptionResMutState<T> {
+unsafe impl<T: Resource> SystemParamState for OptionResMutState<T> {
     type Config = ();
 
     fn init(world: &mut World, system_meta: &mut SystemMeta, _config: Self::Config) -> Self {
@@ -447,7 +450,7 @@ unsafe impl<T: Component> SystemParamState for OptionResMutState<T> {
     fn default_config() {}
 }
 
-impl<'a, T: Component> SystemParamFetch<'a> for OptionResMutState<T> {
+impl<'a, T: Resource> SystemParamFetch<'a> for OptionResMutState<T> {
     type Item = Option<ResMut<'a, T>>;
 
     #[inline]
@@ -532,12 +535,12 @@ impl<'a> SystemParamFetch<'a> for CommandQueue {
 /// // Note how the read local is still 0 due to the locals not being shared.
 /// assert_eq!(read_system.run((), world), 0);
 /// ```
-pub struct Local<'a, T: Component>(&'a mut T);
+pub struct Local<'a, T: Resource>(&'a mut T);
 
 // SAFE: Local only accesses internal state
-unsafe impl<T: Component> ReadOnlySystemParamFetch for LocalState<T> {}
+unsafe impl<T: Resource> ReadOnlySystemParamFetch for LocalState<T> {}
 
-impl<'a, T: Component> Debug for Local<'a, T>
+impl<'a, T: Resource> Debug for Local<'a, T>
 where
     T: Debug,
 {
@@ -546,7 +549,7 @@ where
     }
 }
 
-impl<'a, T: Component> Deref for Local<'a, T> {
+impl<'a, T: Resource> Deref for Local<'a, T> {
     type Target = T;
 
     #[inline]
@@ -555,7 +558,7 @@ impl<'a, T: Component> Deref for Local<'a, T> {
     }
 }
 
-impl<'a, T: Component> DerefMut for Local<'a, T> {
+impl<'a, T: Resource> DerefMut for Local<'a, T> {
     #[inline]
     fn deref_mut(&mut self) -> &mut Self::Target {
         self.0
@@ -563,14 +566,14 @@ impl<'a, T: Component> DerefMut for Local<'a, T> {
 }
 
 /// The [`SystemParamState`] of [`Local`].
-pub struct LocalState<T: Component>(T);
+pub struct LocalState<T: Resource>(T);
 
-impl<'a, T: Component + FromWorld> SystemParam for Local<'a, T> {
+impl<'a, T: Resource + FromWorld> SystemParam for Local<'a, T> {
     type Fetch = LocalState<T>;
 }
 
 // SAFE: only local state is accessed
-unsafe impl<T: Component + FromWorld> SystemParamState for LocalState<T> {
+unsafe impl<T: Resource + FromWorld> SystemParamState for LocalState<T> {
     type Config = Option<T>;
 
     fn init(world: &mut World, _system_meta: &mut SystemMeta, config: Self::Config) -> Self {
@@ -582,7 +585,7 @@ unsafe impl<T: Component + FromWorld> SystemParamState for LocalState<T> {
     }
 }
 
-impl<'a, T: Component + FromWorld> SystemParamFetch<'a> for LocalState<T> {
+impl<'a, T: Resource + FromWorld> SystemParamFetch<'a> for LocalState<T> {
     type Item = Local<'a, T>;
 
     #[inline]
@@ -603,9 +606,11 @@ impl<'a, T: Component + FromWorld> SystemParamFetch<'a> for LocalState<T> {
 /// Basic usage:
 ///
 /// ```
+/// # use bevy_ecs::component::Component;
 /// # use bevy_ecs::system::IntoSystem;
 /// # use bevy_ecs::system::RemovedComponents;
 /// #
+/// # #[derive(Component)]
 /// # struct MyComponent;
 ///
 /// fn react_on_removal(removed: RemovedComponents<MyComponent>) {
@@ -614,13 +619,13 @@ impl<'a, T: Component + FromWorld> SystemParamFetch<'a> for LocalState<T> {
 ///
 /// # react_on_removal.system();
 /// ```
-pub struct RemovedComponents<'a, T> {
+pub struct RemovedComponents<'a, T: Component> {
     world: &'a World,
     component_id: ComponentId,
     marker: PhantomData<T>,
 }
 
-impl<'a, T> RemovedComponents<'a, T> {
+impl<'a, T: Component> RemovedComponents<'a, T> {
     /// Returns an iterator over the entities that had their `T` [`Component`] removed.
     pub fn iter(&self) -> std::iter::Cloned<std::slice::Iter<'_, Entity>> {
         self.world.removed_with_id(self.component_id)
@@ -631,7 +636,7 @@ impl<'a, T> RemovedComponents<'a, T> {
 unsafe impl<T: Component> ReadOnlySystemParamFetch for RemovedComponentsState<T> {}
 
 /// The [`SystemParamState`] of [`RemovedComponents`].
-pub struct RemovedComponentsState<T> {
+pub struct RemovedComponentsState<T: Component> {
     component_id: ComponentId,
     marker: PhantomData<T>,
 }
@@ -702,7 +707,7 @@ where
     }
 }
 
-impl<'w, T: Component> NonSend<'w, T> {
+impl<'w, T> NonSend<'w, T> {
     /// Returns true if (and only if) this resource been added since the last execution of this
     /// system.
     pub fn is_added(&self) -> bool {
@@ -717,7 +722,7 @@ impl<'w, T: Component> NonSend<'w, T> {
     }
 }
 
-impl<'w, T: 'static> Deref for NonSend<'w, T> {
+impl<'w, T> Deref for NonSend<'w, T> {
     type Target = T;
 
     fn deref(&self) -> &Self::Target {
@@ -815,7 +820,7 @@ pub struct NonSendMut<'a, T: 'static> {
     change_tick: u32,
 }
 
-impl<'w, T: Component> NonSendMut<'w, T> {
+impl<'w, T> NonSendMut<'w, T> {
     /// Returns true if (and only if) this resource been added since the last execution of this
     /// system.
     pub fn is_added(&self) -> bool {
@@ -830,7 +835,7 @@ impl<'w, T: Component> NonSendMut<'w, T> {
     }
 }
 
-impl<'a, T: 'static> Deref for NonSendMut<'a, T> {
+impl<'a, T> Deref for NonSendMut<'a, T> {
     type Target = T;
 
     #[inline]
@@ -839,7 +844,7 @@ impl<'a, T: 'static> Deref for NonSendMut<'a, T> {
     }
 }
 
-impl<'a, T: 'static> DerefMut for NonSendMut<'a, T> {
+impl<'a, T> DerefMut for NonSendMut<'a, T> {
     #[inline]
     fn deref_mut(&mut self) -> &mut T {
         self.ticks.set_changed(self.change_tick);
diff --git a/crates/bevy_ecs/src/world/mod.rs b/crates/bevy_ecs/src/world/mod.rs
index 5068fdc4e5074..2e0250258f1da 100644
--- a/crates/bevy_ecs/src/world/mod.rs
+++ b/crates/bevy_ecs/src/world/mod.rs
@@ -19,6 +19,7 @@ use crate::{
     entity::{Entities, Entity},
     query::{FilterFetch, QueryState, WorldQuery},
     storage::{Column, SparseSet, Storages},
+    system::Resource,
 };
 use std::{
     any::TypeId,
@@ -139,8 +140,12 @@ impl World {
     /// The default component storage type can be overridden like this:
     ///
     /// ```
-    /// use bevy_ecs::{component::{ComponentDescriptor, StorageType}, world::World};
+    /// use bevy_ecs::{
+    ///     component::{Component, ComponentDescriptor, StorageType},
+    ///     world::World,
+    /// };
     ///
+    /// #[derive(Component)]
     /// struct Position {
     ///   x: f32,
     ///   y: f32,
@@ -170,8 +175,9 @@ impl World {
     /// to check for entity existence instead of implicitly panic-ing.
     ///
     /// ```
-    /// use bevy_ecs::world::World;
+    /// use bevy_ecs::{component::Component, world::World};
     ///
+    /// #[derive(Component)]
     /// struct Position {
     ///   x: f32,
     ///   y: f32,
@@ -195,8 +201,9 @@ impl World {
     /// to check for entity existence instead of implicitly panic-ing.
     ///
     /// ```
-    /// use bevy_ecs::world::World;
+    /// use bevy_ecs::{component::Component, world::World};
     ///
+    /// #[derive(Component)]
     /// struct Position {
     ///   x: f32,
     ///   y: f32,
@@ -220,8 +227,9 @@ impl World {
     /// to unwrap the [EntityRef] yourself.
     ///
     /// ```
-    /// use bevy_ecs::world::World;
+    /// use bevy_ecs::{component::Component, world::World};
     ///
+    /// #[derive(Component)]
     /// struct Position {
     ///   x: f32,
     ///   y: f32,
@@ -247,8 +255,9 @@ impl World {
     /// to unwrap the [EntityMut] yourself.
     ///
     /// ```
-    /// use bevy_ecs::world::World;
+    /// use bevy_ecs::{component::Component, world::World};
     ///
+    /// #[derive(Component)]
     /// struct Position {
     ///   x: f32,
     ///   y: f32,
@@ -274,17 +283,22 @@ impl World {
     /// to add components to the entity or retrieve its id.
     ///
     /// ```
-    /// use bevy_ecs::world::World;
+    /// use bevy_ecs::{component::Component, world::World};
     ///
+    /// #[derive(Component)]
     /// struct Position {
     ///   x: f32,
     ///   y: f32,
     /// }
+    /// #[derive(Component)]
+    /// struct Label(&'static str);
+    /// #[derive(Component)]
+    /// struct Num(u32);
     ///
     /// let mut world = World::new();
     /// let entity = world.spawn()
     ///     .insert(Position { x: 0.0, y: 0.0 }) // add a single component
-    ///     .insert_bundle((1, 2.0, "hello")) // add a bundle of components
+    ///     .insert_bundle((Num(1), Label("hello"))) // add a bundle of components
     ///     .id();
     ///
     /// let position = world.entity(entity).get::<Position>().unwrap();
@@ -316,12 +330,17 @@ impl World {
     /// individually is more flexible.
     ///
     /// ```
-    /// use bevy_ecs::{entity::Entity, world::World};
+    /// use bevy_ecs::{component::Component, entity::Entity, world::World};
+    ///
+    /// #[derive(Component)]
+    /// struct Str(&'static str);
+    /// #[derive(Component)]
+    /// struct Num(u32);
     ///
     /// let mut world = World::new();
     /// let entities = world.spawn_batch(vec![
-    ///   ("a", 0.0), // the first entity
-    ///   ("b", 1.0), // the second entity
+    ///   (Str("a"), Num(0)), // the first entity
+    ///   (Str("b"), Num(1)), // the second entity
     /// ]).collect::<Vec<Entity>>();
     ///
     /// assert_eq!(entities.len(), 2);
@@ -337,8 +356,9 @@ impl World {
     /// Retrieves a reference to the given `entity`'s [Component] of the given type.
     /// Returns [None] if the `entity` does not have a [Component] of the given type.
     /// ```
-    /// use bevy_ecs::world::World;
+    /// use bevy_ecs::{component::Component, world::World};
     ///
+    /// #[derive(Component)]
     /// struct Position {
     ///   x: f32,
     ///   y: f32,
@@ -358,8 +378,9 @@ impl World {
     /// Retrieves a mutable reference to the given `entity`'s [Component] of the given type.
     /// Returns [None] if the `entity` does not have a [Component] of the given type.
     /// ```
-    /// use bevy_ecs::world::World;
+    /// use bevy_ecs::{component::Component, world::World};
     ///
+    /// #[derive(Component)]
     /// struct Position {
     ///   x: f32,
     ///   y: f32,
@@ -380,8 +401,9 @@ impl World {
     /// [Component]s. Returns `true` if the `entity` is successfully despawned and `false` if
     /// the `entity` does not exist.
     /// ```
-    /// use bevy_ecs::world::World;
+    /// use bevy_ecs::{component::Component, world::World};
     ///
+    /// #[derive(Component)]
     /// struct Position {
     ///   x: f32,
     ///   y: f32,
@@ -417,14 +439,15 @@ impl World {
     /// Returns [QueryState] for the given [WorldQuery], which is used to efficiently
     /// run queries on the [World] by storing and reusing the [QueryState].
     /// ```
-    /// use bevy_ecs::{entity::Entity, world::World};
+    /// use bevy_ecs::{component::Component, entity::Entity, world::World};
     ///
-    /// #[derive(Debug, PartialEq)]
+    /// #[derive(Component, Debug, PartialEq)]
     /// struct Position {
     ///   x: f32,
     ///   y: f32,
     /// }
     ///
+    /// #[derive(Component)]
     /// struct Velocity {
     ///   x: f32,
     ///   y: f32,
@@ -452,18 +475,28 @@ impl World {
     /// and allocation of a [Vec] to store it.
     ///
     /// ```
-    /// use bevy_ecs::{entity::Entity, world::World};
+    /// use bevy_ecs::{component::Component, entity::Entity, world::World};
+    ///
+    /// #[derive(Component, PartialEq, Eq, PartialOrd, Ord, Debug)]
+    /// struct Order(i32);
+    /// #[derive(Component, PartialEq, Debug)]
+    /// struct Label(&'static str);
+    ///
     /// let mut world = World::new();
-    /// let a = world.spawn().insert_bundle((2, 4.0)).id();
-    /// let b = world.spawn().insert_bundle((3, 5.0)).id();
-    /// let c = world.spawn().insert_bundle((1, 6.0)).id();
-    /// let mut entities = world.query::<(Entity, &i32, &f64)>()
+    /// let a = world.spawn().insert_bundle((Order(2), Label("second"))).id();
+    /// let b = world.spawn().insert_bundle((Order(3), Label("third"))).id();
+    /// let c = world.spawn().insert_bundle((Order(1), Label("first"))).id();
+    /// let mut entities = world.query::<(Entity, &Order, &Label)>()
     ///     .iter(&world)
     ///     .collect::<Vec<_>>();
-    /// // Sort the query results by their `i32` component before comparing
+    /// // Sort the query results by their `Order` component before comparing
     /// // to expected results. Query iteration order should not be relied on.
     /// entities.sort_by_key(|e| e.1);
-    /// assert_eq!(entities, vec![(c, &1, &6.0), (a, &2, &4.0), (b, &3, &5.0)]);
+    /// assert_eq!(entities, vec![
+    ///     (c, &Order(1), &Label("first")),
+    ///     (a, &Order(2), &Label("second")),
+    ///     (b, &Order(3), &Label("third")),
+    /// ]);
     /// ```
     #[inline]
     pub fn query<Q: WorldQuery>(&mut self) -> QueryState<Q, ()> {
@@ -473,9 +506,11 @@ impl World {
     /// Returns [QueryState] for the given filtered [WorldQuery], which is used to efficiently
     /// run queries on the [World] by storing and reusing the [QueryState].
     /// ```
-    /// use bevy_ecs::{entity::Entity, world::World, query::With};
+    /// use bevy_ecs::{component::Component, entity::Entity, world::World, query::With};
     ///
+    /// #[derive(Component)]
     /// struct A;
+    /// #[derive(Component)]
     /// struct B;
     ///
     /// let mut world = World::new();
@@ -521,7 +556,7 @@ impl World {
     /// Inserts a new resource with the given `value`.
     /// Resources are "unique" data of a given type.
     #[inline]
-    pub fn insert_resource<T: Component>(&mut self, value: T) {
+    pub fn insert_resource<T: Resource>(&mut self, value: T) {
         let component_id = self.components.get_or_insert_resource_id::<T>();
         // SAFE: component_id just initialized and corresponds to resource of type T
         unsafe { self.insert_resource_with_id(component_id, value) };
@@ -540,7 +575,7 @@ impl World {
     /// Removes the resource of a given type and returns it, if it exists. Otherwise returns [None].
     /// Resources are "unique" data of a given type.
     #[inline]
-    pub fn remove_resource<T: Component>(&mut self) -> Option<T> {
+    pub fn remove_resource<T: Resource>(&mut self) -> Option<T> {
         // SAFE: T is Send + Sync
         unsafe { self.remove_resource_unchecked() }
     }
@@ -573,7 +608,7 @@ impl World {
 
     /// Returns `true` if a resource of type `T` exists. Otherwise returns `false`.
     #[inline]
-    pub fn contains_resource<T: Component>(&self) -> bool {
+    pub fn contains_resource<T: Resource>(&self) -> bool {
         let component_id =
             if let Some(component_id) = self.components.get_resource_id(TypeId::of::<T>()) {
                 component_id
@@ -586,12 +621,12 @@ impl World {
     /// Gets a reference to the resource of the given type, if it exists. Otherwise returns [None]
     /// Resources are "unique" data of a given type.
     #[inline]
-    pub fn get_resource<T: Component>(&self) -> Option<&T> {
+    pub fn get_resource<T: Resource>(&self) -> Option<&T> {
         let component_id = self.components.get_resource_id(TypeId::of::<T>())?;
         unsafe { self.get_resource_with_id(component_id) }
     }
 
-    pub fn is_resource_added<T: Component>(&self) -> bool {
+    pub fn is_resource_added<T: Resource>(&self) -> bool {
         let component_id = self.components.get_resource_id(TypeId::of::<T>()).unwrap();
         let column = self.get_populated_resource_column(component_id).unwrap();
         // SAFE: resources table always have row 0
@@ -599,7 +634,7 @@ impl World {
         ticks.is_added(self.last_change_tick(), self.read_change_tick())
     }
 
-    pub fn is_resource_changed<T: Component>(&self) -> bool {
+    pub fn is_resource_changed<T: Resource>(&self) -> bool {
         let component_id = self.components.get_resource_id(TypeId::of::<T>()).unwrap();
         let column = self.get_populated_resource_column(component_id).unwrap();
         // SAFE: resources table always have row 0
@@ -610,7 +645,7 @@ impl World {
     /// Gets a mutable reference to the resource of the given type, if it exists. Otherwise returns
     /// [None] Resources are "unique" data of a given type.
     #[inline]
-    pub fn get_resource_mut<T: Component>(&mut self) -> Option<Mut<'_, T>> {
+    pub fn get_resource_mut<T: Resource>(&mut self) -> Option<Mut<'_, T>> {
         // SAFE: unique world access
         unsafe { self.get_resource_unchecked_mut() }
     }
@@ -619,7 +654,7 @@ impl World {
     /// Gets a resource of type `T` if it exists, otherwise inserts the resource using the result of
     /// calling `func`.
     #[inline]
-    pub fn get_resource_or_insert_with<T: Component>(
+    pub fn get_resource_or_insert_with<T: Resource>(
         &mut self,
         func: impl FnOnce() -> T,
     ) -> Mut<'_, T> {
@@ -636,7 +671,7 @@ impl World {
     /// This will allow aliased mutable access to the given resource type. The caller must ensure
     /// that only one mutable access exists at a time.
     #[inline]
-    pub unsafe fn get_resource_unchecked_mut<T: Component>(&self) -> Option<Mut<'_, T>> {
+    pub unsafe fn get_resource_unchecked_mut<T: Resource>(&self) -> Option<Mut<'_, T>> {
         let component_id = self.components.get_resource_id(TypeId::of::<T>())?;
         self.get_resource_unchecked_mut_with_id(component_id)
     }
@@ -674,8 +709,10 @@ impl World {
     /// returning. This enables safe mutable access to a resource while still providing mutable
     /// world access
     /// ```
-    /// use bevy_ecs::world::{World, Mut};
+    /// use bevy_ecs::{component::Component, world::{World, Mut}};
+    /// #[derive(Component)]
     /// struct A(u32);
+    /// #[derive(Component)]
     /// struct B(u32);
     /// let mut world = World::new();
     /// world.insert_resource(A(1));
@@ -687,10 +724,7 @@ impl World {
     /// });
     /// assert_eq!(world.get_resource::<A>().unwrap().0, 2);
     /// ```
-    pub fn resource_scope<T: Component, U>(
-        &mut self,
-        f: impl FnOnce(&mut World, Mut<T>) -> U,
-    ) -> U {
+    pub fn resource_scope<T: Resource, U>(&mut self, f: impl FnOnce(&mut World, Mut<T>) -> U) -> U {
         let component_id = self
             .components
             .get_resource_id(TypeId::of::<T>())
@@ -831,7 +865,7 @@ impl World {
             })
     }
 
-    pub(crate) fn initialize_resource<T: Component>(&mut self) -> ComponentId {
+    pub(crate) fn initialize_resource<T: Resource>(&mut self) -> ComponentId {
         let component_id = self.components.get_or_insert_resource_id::<T>();
         // SAFE: resource initialized above
         unsafe { self.initialize_resource_internal(component_id) };
diff --git a/crates/bevy_ecs/src/world/world_cell.rs b/crates/bevy_ecs/src/world/world_cell.rs
index e128167d5610d..126398cdef5d6 100644
--- a/crates/bevy_ecs/src/world/world_cell.rs
+++ b/crates/bevy_ecs/src/world/world_cell.rs
@@ -1,7 +1,7 @@
 use crate::{
     archetype::ArchetypeComponentId,
-    component::Component,
     storage::SparseSet,
+    system::Resource,
     world::{Mut, World},
 };
 use std::{
@@ -182,7 +182,7 @@ impl<'w> WorldCell<'w> {
         }
     }
 
-    pub fn get_resource<T: Component>(&self) -> Option<WorldBorrow<'_, T>> {
+    pub fn get_resource<T: Resource>(&self) -> Option<WorldBorrow<'_, T>> {
         let component_id = self.world.components.get_resource_id(TypeId::of::<T>())?;
         let resource_archetype = self.world.archetypes.resource();
         let archetype_component_id = resource_archetype.get_archetype_component_id(component_id)?;
@@ -194,7 +194,7 @@ impl<'w> WorldCell<'w> {
         ))
     }
 
-    pub fn get_resource_mut<T: Component>(&self) -> Option<WorldBorrowMut<'_, T>> {
+    pub fn get_resource_mut<T: Resource>(&self) -> Option<WorldBorrowMut<'_, T>> {
         let component_id = self.world.components.get_resource_id(TypeId::of::<T>())?;
         let resource_archetype = self.world.archetypes.resource();
         let archetype_component_id = resource_archetype.get_archetype_component_id(component_id)?;
diff --git a/crates/bevy_pbr/src/light.rs b/crates/bevy_pbr/src/light.rs
index 343bb6888f38d..7ef672045775f 100644
--- a/crates/bevy_pbr/src/light.rs
+++ b/crates/bevy_pbr/src/light.rs
@@ -1,12 +1,12 @@
 use bevy_core::{Pod, Zeroable};
-use bevy_ecs::reflect::ReflectComponent;
+use bevy_ecs::{component::Component, reflect::ReflectComponent};
 use bevy_math::Vec3;
 use bevy_reflect::Reflect;
 use bevy_render::color::Color;
 use bevy_transform::components::GlobalTransform;
 
 /// A point light
-#[derive(Debug, Clone, Copy, Reflect)]
+#[derive(Component, Debug, Clone, Copy, Reflect)]
 #[reflect(Component)]
 pub struct PointLight {
     pub color: Color,
@@ -77,7 +77,7 @@ impl PointLightUniform {
 /// | 32,000–100,000    | Direct sunlight                                |
 ///
 /// Source: [Wikipedia](https://en.wikipedia.org/wiki/Lux)
-#[derive(Debug, Clone, Copy, Reflect)]
+#[derive(Component, Debug, Clone, Copy, Reflect)]
 #[reflect(Component)]
 pub struct DirectionalLight {
     pub color: Color,
diff --git a/crates/bevy_pbr/src/material.rs b/crates/bevy_pbr/src/material.rs
index 73c1f80ac6a4e..a2f1f0117d72a 100644
--- a/crates/bevy_pbr/src/material.rs
+++ b/crates/bevy_pbr/src/material.rs
@@ -1,10 +1,11 @@
 use bevy_asset::{self, Handle};
+use bevy_ecs::component::Component;
 use bevy_reflect::TypeUuid;
 use bevy_render::{color::Color, renderer::RenderResources, shader::ShaderDefs, texture::Texture};
 
 /// A material with "standard" properties used in PBR lighting
 /// Standard property values with pictures here https://google.github.io/filament/Material%20Properties.pdf
-#[derive(Debug, RenderResources, ShaderDefs, TypeUuid)]
+#[derive(Component, Debug, RenderResources, ShaderDefs, TypeUuid)]
 #[uuid = "dace545e-4bc6-4595-a79d-c224fc694975"]
 pub struct StandardMaterial {
     /// Doubles as diffuse albedo for non-metallic, specular for metallic and a mix for everything
diff --git a/crates/bevy_render/src/camera/active_cameras.rs b/crates/bevy_render/src/camera/active_cameras.rs
index 467614b895ea8..37543dc8f34f7 100644
--- a/crates/bevy_render/src/camera/active_cameras.rs
+++ b/crates/bevy_render/src/camera/active_cameras.rs
@@ -2,12 +2,13 @@ use crate::renderer::RenderResourceBindings;
 
 use super::Camera;
 use bevy_ecs::{
+    component::Component,
     entity::Entity,
     system::{Query, ResMut},
 };
 use bevy_utils::HashMap;
 
-#[derive(Debug, Default)]
+#[derive(Component, Debug, Default)]
 pub struct ActiveCamera {
     pub name: String,
     pub entity: Option<Entity>,
diff --git a/crates/bevy_render/src/camera/camera.rs b/crates/bevy_render/src/camera/camera.rs
index f3f63ca40a6f3..41a31f42b81c5 100644
--- a/crates/bevy_render/src/camera/camera.rs
+++ b/crates/bevy_render/src/camera/camera.rs
@@ -14,7 +14,7 @@ use bevy_transform::components::GlobalTransform;
 use bevy_window::{WindowCreated, WindowId, WindowResized, Windows};
 use serde::{Deserialize, Serialize};
 
-#[derive(Default, Debug, Reflect)]
+#[derive(Component, Default, Debug, Reflect)]
 #[reflect(Component)]
 pub struct Camera {
     pub projection_matrix: Mat4,
diff --git a/crates/bevy_render/src/camera/projection.rs b/crates/bevy_render/src/camera/projection.rs
index 4e227654f9d24..62d66418f9cbc 100644
--- a/crates/bevy_render/src/camera/projection.rs
+++ b/crates/bevy_render/src/camera/projection.rs
@@ -1,5 +1,5 @@
 use super::DepthCalculation;
-use bevy_ecs::reflect::ReflectComponent;
+use bevy_ecs::{component::Component, reflect::ReflectComponent};
 use bevy_math::Mat4;
 use bevy_reflect::{Reflect, ReflectDeserialize};
 use serde::{Deserialize, Serialize};
@@ -10,7 +10,7 @@ pub trait CameraProjection {
     fn depth_calculation(&self) -> DepthCalculation;
 }
 
-#[derive(Debug, Clone, Reflect)]
+#[derive(Component, Debug, Clone, Reflect)]
 #[reflect(Component)]
 pub struct PerspectiveProjection {
     pub fov: f32,
@@ -66,7 +66,7 @@ pub enum ScalingMode {
     FixedHorizontal,
 }
 
-#[derive(Debug, Clone, Reflect)]
+#[derive(Component, Debug, Clone, Reflect)]
 #[reflect(Component)]
 pub struct OrthographicProjection {
     pub left: f32,
diff --git a/crates/bevy_render/src/camera/visible_entities.rs b/crates/bevy_render/src/camera/visible_entities.rs
index 1fd0a9da460bc..4c84eb7f267cc 100644
--- a/crates/bevy_render/src/camera/visible_entities.rs
+++ b/crates/bevy_render/src/camera/visible_entities.rs
@@ -1,7 +1,9 @@
 use super::{Camera, DepthCalculation};
 use crate::{draw::OutsideFrustum, prelude::Visible};
 use bevy_core::FloatOrd;
-use bevy_ecs::{entity::Entity, query::Without, reflect::ReflectComponent, system::Query};
+use bevy_ecs::{
+    component::Component, entity::Entity, query::Without, reflect::ReflectComponent, system::Query,
+};
 use bevy_reflect::Reflect;
 use bevy_transform::prelude::GlobalTransform;
 
@@ -11,7 +13,7 @@ pub struct VisibleEntity {
     pub order: FloatOrd,
 }
 
-#[derive(Default, Debug, Reflect)]
+#[derive(Component, Default, Debug, Reflect)]
 #[reflect(Component)]
 pub struct VisibleEntities {
     #[reflect(ignore)]
@@ -42,7 +44,7 @@ pub type Layer = u8;
 /// An entity with this component without any layers is invisible.
 ///
 /// Entities without this component belong to layer `0`.
-#[derive(Copy, Clone, Reflect, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Component, Copy, Clone, Reflect, PartialEq, Eq, PartialOrd, Ord)]
 #[reflect(Component, PartialEq)]
 pub struct RenderLayers(LayerMask);
 
diff --git a/crates/bevy_render/src/draw.rs b/crates/bevy_render/src/draw.rs
index 6faac65c32865..1006ec4166a4d 100644
--- a/crates/bevy_render/src/draw.rs
+++ b/crates/bevy_render/src/draw.rs
@@ -10,6 +10,7 @@ use crate::{
 };
 use bevy_asset::{Asset, Assets, Handle};
 use bevy_ecs::{
+    component::Component,
     reflect::ReflectComponent,
     system::{Query, Res, ResMut, SystemParam},
 };
@@ -49,7 +50,7 @@ pub enum RenderCommand {
     },
 }
 
-#[derive(Debug, Clone, Reflect)]
+#[derive(Component, Debug, Clone, Reflect)]
 #[reflect(Component)]
 pub struct Visible {
     pub is_visible: bool,
@@ -73,12 +74,12 @@ impl Default for Visible {
 /// This does not handle multiple "views" properly as it is a "global" filter.
 /// This will be resolved in the future. For now, disable frustum culling if you
 /// need to support multiple views (ex: set the `SpriteSettings::frustum_culling_enabled` resource).
-#[derive(Debug, Default, Clone, Reflect)]
+#[derive(Component, Debug, Default, Clone, Reflect)]
 #[reflect(Component)]
 pub struct OutsideFrustum;
 
 /// A component that indicates how to draw an entity.
-#[derive(Debug, Clone, Reflect)]
+#[derive(Component, Debug, Clone, Reflect)]
 #[reflect(Component)]
 pub struct Draw {
     #[reflect(ignore)]
diff --git a/crates/bevy_render/src/pipeline/render_pipelines.rs b/crates/bevy_render/src/pipeline/render_pipelines.rs
index ff3a041118501..13ac09e429abf 100644
--- a/crates/bevy_render/src/pipeline/render_pipelines.rs
+++ b/crates/bevy_render/src/pipeline/render_pipelines.rs
@@ -7,6 +7,7 @@ use crate::{
 };
 use bevy_asset::{Assets, Handle};
 use bevy_ecs::{
+    component::Component,
     query::Without,
     reflect::ReflectComponent,
     system::{Query, Res, ResMut},
@@ -44,7 +45,7 @@ impl RenderPipeline {
     }
 }
 
-#[derive(Debug, Clone, Reflect)]
+#[derive(Component, Debug, Clone, Reflect)]
 #[reflect(Component)]
 pub struct RenderPipelines {
     pub pipelines: Vec<RenderPipeline>,
diff --git a/crates/bevy_render/src/render_graph/base.rs b/crates/bevy_render/src/render_graph/base.rs
index 6937c5b0a228a..160039a8b0db6 100644
--- a/crates/bevy_render/src/render_graph/base.rs
+++ b/crates/bevy_render/src/render_graph/base.rs
@@ -10,12 +10,12 @@ use crate::{
     texture::{Extent3d, TextureDescriptor, TextureDimension, TextureFormat, TextureUsage},
     Color,
 };
-use bevy_ecs::{reflect::ReflectComponent, world::World};
+use bevy_ecs::{component::Component, reflect::ReflectComponent, world::World};
 use bevy_reflect::Reflect;
 use bevy_window::WindowId;
 
 /// A component that indicates that an entity should be drawn in the "main pass"
-#[derive(Clone, Debug, Default, Reflect)]
+#[derive(Component, Clone, Debug, Default, Reflect)]
 #[reflect(Component)]
 pub struct MainPass;
 
diff --git a/crates/bevy_render/src/render_graph/nodes/render_resources_node.rs b/crates/bevy_render/src/render_graph/nodes/render_resources_node.rs
index 0901a7782d9db..ee3f5ebe8cdd6 100644
--- a/crates/bevy_render/src/render_graph/nodes/render_resources_node.rs
+++ b/crates/bevy_render/src/render_graph/nodes/render_resources_node.rs
@@ -12,6 +12,7 @@ use crate::{
 use bevy_app::EventReader;
 use bevy_asset::{Asset, AssetEvent, Assets, Handle, HandleId};
 use bevy_ecs::{
+    component::Component,
     entity::Entity,
     query::{Changed, Or, With},
     system::{BoxedSystem, IntoSystem, Local, Query, QuerySet, RemovedComponents, Res, ResMut},
@@ -397,7 +398,7 @@ where
 
 impl<T> SystemNode for RenderResourcesNode<T>
 where
-    T: renderer::RenderResources,
+    T: renderer::RenderResources + Component,
 {
     fn get_system(&self) -> BoxedSystem {
         let system = render_resources_node_system::<T>.system().config(|config| {
@@ -429,7 +430,7 @@ impl<I, T: RenderResources> Default for RenderResourcesNodeState<I, T> {
 }
 
 #[allow(clippy::type_complexity)]
-fn render_resources_node_system<T: RenderResources>(
+fn render_resources_node_system<T: RenderResources + Component>(
     mut state: Local<RenderResourcesNodeState<Entity, T>>,
     mut entities_waiting_for_textures: Local<Vec<Entity>>,
     render_resource_context: Res<Box<dyn RenderResourceContext>>,
diff --git a/crates/bevy_render/src/shader/shader_defs.rs b/crates/bevy_render/src/shader/shader_defs.rs
index 1e61b1d9edbf5..bf579be454318 100644
--- a/crates/bevy_render/src/shader/shader_defs.rs
+++ b/crates/bevy_render/src/shader/shader_defs.rs
@@ -3,6 +3,7 @@ use bevy_asset::{Asset, Assets, Handle};
 use crate::{draw::OutsideFrustum, pipeline::RenderPipelines, Texture};
 pub use bevy_derive::ShaderDefs;
 use bevy_ecs::{
+    prelude::Component,
     query::Without,
     system::{Query, Res},
 };
@@ -70,7 +71,7 @@ impl ShaderDef for Option<Handle<Texture>> {
 /// Updates [RenderPipelines] with the latest [ShaderDefs]
 pub fn shader_defs_system<T>(mut query: Query<(&T, &mut RenderPipelines), Without<OutsideFrustum>>)
 where
-    T: ShaderDefs + Send + Sync + 'static,
+    T: ShaderDefs + Component,
 {
     for (shader_defs, mut render_pipelines) in query.iter_mut() {
         for shader_def in shader_defs.iter_shader_defs() {
diff --git a/crates/bevy_render/src/wireframe/mod.rs b/crates/bevy_render/src/wireframe/mod.rs
index a2862d4ee3c5e..4c608e6c99c17 100644
--- a/crates/bevy_render/src/wireframe/mod.rs
+++ b/crates/bevy_render/src/wireframe/mod.rs
@@ -8,6 +8,7 @@ use crate::{
 use bevy_app::prelude::*;
 use bevy_asset::{Assets, Handle, HandleUntyped};
 use bevy_ecs::{
+    component::Component,
     query::With,
     reflect::ReflectComponent,
     system::{IntoSystem, Query, QuerySet, Res},
@@ -40,7 +41,7 @@ impl Plugin for WireframePlugin {
     }
 }
 
-#[derive(Debug, Clone, Reflect, Default)]
+#[derive(Component, Debug, Clone, Reflect, Default)]
 #[reflect(Component)]
 pub struct Wireframe;
 
diff --git a/crates/bevy_sprite/src/sprite.rs b/crates/bevy_sprite/src/sprite.rs
index 4a36eb11f49f9..b5ab716975e5d 100644
--- a/crates/bevy_sprite/src/sprite.rs
+++ b/crates/bevy_sprite/src/sprite.rs
@@ -2,6 +2,7 @@ use crate::ColorMaterial;
 use bevy_asset::{Assets, Handle};
 use bevy_core::Bytes;
 use bevy_ecs::{
+    component::Component,
     query::Without,
     system::{Query, Res},
 };
@@ -15,7 +16,7 @@ use bevy_render::{
 use serde::{Deserialize, Serialize};
 
 /// General Sprite Examples: [Link](https://github.com/bevyengine/bevy/tree/latest/examples/2d)
-#[derive(Debug, Default, Clone, TypeUuid, Reflect, RenderResources)]
+#[derive(Component, Debug, Default, Clone, TypeUuid, Reflect, RenderResources)]
 #[render_resources(from_self)]
 #[uuid = "7233c597-ccfa-411f-bd59-9af349432ada"]
 #[repr(C)]
diff --git a/crates/bevy_sprite/src/texture_atlas.rs b/crates/bevy_sprite/src/texture_atlas.rs
index 6677b9562bea4..9e7cf6978511b 100644
--- a/crates/bevy_sprite/src/texture_atlas.rs
+++ b/crates/bevy_sprite/src/texture_atlas.rs
@@ -1,6 +1,7 @@
 use crate::Rect;
 use bevy_asset::Handle;
 use bevy_core::Bytes;
+use bevy_ecs::component::Component;
 use bevy_math::Vec2;
 use bevy_reflect::TypeUuid;
 use bevy_render::{
@@ -27,7 +28,7 @@ pub struct TextureAtlas {
     pub texture_handles: Option<HashMap<Handle<Texture>, usize>>,
 }
 
-#[derive(Debug, Clone, RenderResources)]
+#[derive(Component, Debug, Clone, RenderResources)]
 #[render_resources(from_self)]
 #[repr(C)]
 pub struct TextureAtlasSprite {
diff --git a/crates/bevy_text/src/text.rs b/crates/bevy_text/src/text.rs
index b077c2821574c..bcb2ed858246f 100644
--- a/crates/bevy_text/src/text.rs
+++ b/crates/bevy_text/src/text.rs
@@ -1,11 +1,12 @@
 use bevy_asset::Handle;
+use bevy_ecs::component::Component;
 use bevy_math::Size;
 use bevy_render::color::Color;
 use glyph_brush_layout::{HorizontalAlign, VerticalAlign};
 
 use crate::Font;
 
-#[derive(Debug, Default, Clone)]
+#[derive(Component, Debug, Default, Clone)]
 pub struct Text {
     pub sections: Vec<TextSection>,
     pub alignment: TextAlignment,
@@ -101,7 +102,7 @@ impl Default for TextStyle {
     }
 }
 
-#[derive(Default, Copy, Clone, Debug)]
+#[derive(Component, Default, Copy, Clone, Debug)]
 pub struct Text2dSize {
     pub size: Size,
 }
diff --git a/crates/bevy_transform/src/components/children.rs b/crates/bevy_transform/src/components/children.rs
index c1bc5c317718d..af523d77ea90d 100644
--- a/crates/bevy_transform/src/components/children.rs
+++ b/crates/bevy_transform/src/components/children.rs
@@ -1,4 +1,5 @@
 use bevy_ecs::{
+    component::Component,
     entity::{Entity, EntityMap, MapEntities, MapEntitiesError},
     reflect::{ReflectComponent, ReflectMapEntities},
 };
@@ -6,7 +7,7 @@ use bevy_reflect::Reflect;
 use smallvec::SmallVec;
 use std::ops::Deref;
 
-#[derive(Default, Clone, Debug, Reflect)]
+#[derive(Component, Default, Clone, Debug, Reflect)]
 #[reflect(Component, MapEntities)]
 pub struct Children(pub(crate) SmallVec<[Entity; 8]>);
 
diff --git a/crates/bevy_transform/src/components/global_transform.rs b/crates/bevy_transform/src/components/global_transform.rs
index ceca829bc74f6..1007299e1a763 100644
--- a/crates/bevy_transform/src/components/global_transform.rs
+++ b/crates/bevy_transform/src/components/global_transform.rs
@@ -1,5 +1,5 @@
 use super::Transform;
-use bevy_ecs::reflect::ReflectComponent;
+use bevy_ecs::{component::Component, reflect::ReflectComponent};
 use bevy_math::{Mat3, Mat4, Quat, Vec3};
 use bevy_reflect::Reflect;
 use std::ops::Mul;
@@ -33,7 +33,7 @@ use std::ops::Mul;
 /// This system runs in stage [`CoreStage::PostUpdate`](crate::CoreStage::PostUpdate). If you
 /// update the[`Transform`] of an entity in this stage or after, you will notice a 1 frame lag
 /// before the [`GlobalTransform`] is updated.
-#[derive(Debug, PartialEq, Clone, Copy, Reflect)]
+#[derive(Component, Debug, PartialEq, Clone, Copy, Reflect)]
 #[reflect(Component, PartialEq)]
 pub struct GlobalTransform {
     pub translation: Vec3,
diff --git a/crates/bevy_transform/src/components/parent.rs b/crates/bevy_transform/src/components/parent.rs
index 8f65d3a81d1bb..5940fc60d1013 100644
--- a/crates/bevy_transform/src/components/parent.rs
+++ b/crates/bevy_transform/src/components/parent.rs
@@ -1,4 +1,5 @@
 use bevy_ecs::{
+    component::Component,
     entity::{Entity, EntityMap, MapEntities, MapEntitiesError},
     reflect::{ReflectComponent, ReflectMapEntities},
     world::{FromWorld, World},
@@ -6,7 +7,7 @@ use bevy_ecs::{
 use bevy_reflect::Reflect;
 use std::ops::{Deref, DerefMut};
 
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Reflect)]
+#[derive(Component, Debug, Copy, Clone, Eq, PartialEq, Reflect)]
 #[reflect(Component, MapEntities, PartialEq)]
 pub struct Parent(pub Entity);
 
@@ -41,7 +42,7 @@ impl DerefMut for Parent {
     }
 }
 
-#[derive(Debug, Copy, Clone, Eq, PartialEq, Reflect)]
+#[derive(Component, Debug, Copy, Clone, Eq, PartialEq, Reflect)]
 #[reflect(Component, MapEntities, PartialEq)]
 pub struct PreviousParent(pub(crate) Entity);
 
diff --git a/crates/bevy_transform/src/components/transform.rs b/crates/bevy_transform/src/components/transform.rs
index f4a538d30ecb8..d79d727977013 100644
--- a/crates/bevy_transform/src/components/transform.rs
+++ b/crates/bevy_transform/src/components/transform.rs
@@ -1,5 +1,5 @@
 use super::GlobalTransform;
-use bevy_ecs::reflect::ReflectComponent;
+use bevy_ecs::{component::Component, reflect::ReflectComponent};
 use bevy_math::{Mat3, Mat4, Quat, Vec3};
 use bevy_reflect::Reflect;
 use std::ops::Mul;
@@ -34,7 +34,7 @@ use std::ops::Mul;
 /// This system runs in stage [`CoreStage::PostUpdate`](crate::CoreStage::PostUpdate). If you
 /// update the[`Transform`] of an entity in this stage or after, you will notice a 1 frame lag
 /// before the [`GlobalTransform`] is updated.
-#[derive(Debug, PartialEq, Clone, Copy, Reflect)]
+#[derive(Component, Debug, PartialEq, Clone, Copy, Reflect)]
 #[reflect(Component, PartialEq)]
 pub struct Transform {
     /// Position of the entity. In 2d, the last value of the `Vec3` is used for z-ordering.
diff --git a/crates/bevy_transform/src/hierarchy/child_builder.rs b/crates/bevy_transform/src/hierarchy/child_builder.rs
index 1c1ab208eefa4..cb4f2cd4d0cef 100644
--- a/crates/bevy_transform/src/hierarchy/child_builder.rs
+++ b/crates/bevy_transform/src/hierarchy/child_builder.rs
@@ -322,12 +322,16 @@ mod tests {
     use super::{BuildChildren, BuildWorldChildren};
     use crate::prelude::{Children, Parent, PreviousParent};
     use bevy_ecs::{
+        component::Component,
         entity::Entity,
         system::{CommandQueue, Commands},
         world::World,
     };
     use smallvec::{smallvec, SmallVec};
 
+    #[derive(Component)]
+    struct C(u32);
+
     #[test]
     fn build_children() {
         let mut world = World::default();
@@ -335,11 +339,11 @@ mod tests {
         let mut commands = Commands::new(&mut queue, &world);
 
         let mut children = Vec::new();
-        let parent = commands.spawn().insert(1).id();
+        let parent = commands.spawn().insert(C(1)).id();
         commands.entity(parent).with_children(|parent| {
-            children.push(parent.spawn().insert(2).id());
-            children.push(parent.spawn().insert(3).id());
-            children.push(parent.spawn().insert(4).id());
+            children.push(parent.spawn().insert(C(2)).id());
+            children.push(parent.spawn().insert(C(3)).id());
+            children.push(parent.spawn().insert(C(4)).id());
         });
 
         queue.apply(&mut world);
@@ -365,7 +369,7 @@ mod tests {
         let mut world = World::default();
 
         let entities = world
-            .spawn_batch(vec![(1,), (2,), (3,), (4,), (5,)])
+            .spawn_batch(vec![(C(1),), (C(2),), (C(3),), (C(4),), (C(5),)])
             .collect::<Vec<Entity>>();
 
         let mut queue = CommandQueue::default();
@@ -426,7 +430,7 @@ mod tests {
         let mut world = World::default();
 
         let entities = world
-            .spawn_batch(vec![(1,), (2,), (3,), (4,), (5,)])
+            .spawn_batch(vec![(C(1),), (C(2),), (C(3),), (C(4),), (C(5),)])
             .collect::<Vec<Entity>>();
 
         world.entity_mut(entities[0]).push_children(&entities[1..3]);
diff --git a/crates/bevy_transform/src/hierarchy/hierarchy.rs b/crates/bevy_transform/src/hierarchy/hierarchy.rs
index e7c339342096a..1c8c82a7098c0 100644
--- a/crates/bevy_transform/src/hierarchy/hierarchy.rs
+++ b/crates/bevy_transform/src/hierarchy/hierarchy.rs
@@ -58,6 +58,7 @@ impl<'a, 'b> DespawnRecursiveExt for EntityCommands<'a, 'b> {
 #[cfg(test)]
 mod tests {
     use bevy_ecs::{
+        component::Component,
         system::{CommandQueue, Commands},
         world::World,
     };
@@ -65,6 +66,12 @@ mod tests {
     use super::DespawnRecursiveExt;
     use crate::{components::Children, hierarchy::BuildChildren};
 
+    #[derive(Component, Clone, Copy, PartialEq, Eq, Ord, PartialOrd, Debug)]
+    struct Idx(u32);
+
+    #[derive(Component, Clone, PartialEq, Eq, Ord, PartialOrd, Debug)]
+    struct N(String);
+
     #[test]
     fn despawn_recursive() {
         let mut world = World::default();
@@ -74,33 +81,35 @@ mod tests {
             let mut commands = Commands::new(&mut queue, &world);
 
             commands
-                .spawn_bundle(("Another parent".to_owned(), 0u32))
+                .spawn_bundle((N("Another parent".to_owned()), Idx(0)))
                 .with_children(|parent| {
-                    parent.spawn_bundle(("Another child".to_owned(), 1u32));
+                    parent.spawn_bundle((N("Another child".to_owned()), Idx(1)));
                 });
 
             // Create a grandparent entity which will _not_ be deleted
-            grandparent_entity = commands.spawn_bundle(("Grandparent".to_owned(), 2u32)).id();
+            grandparent_entity = commands
+                .spawn_bundle((N("Grandparent".to_owned()), Idx(2)))
+                .id();
             commands.entity(grandparent_entity).with_children(|parent| {
                 // Add a child to the grandparent (the "parent"), which will get deleted
                 parent
-                    .spawn_bundle(("Parent, to be deleted".to_owned(), 3u32))
+                    .spawn_bundle((N("Parent, to be deleted".to_owned()), Idx(3)))
                     // All descendents of the "parent" should also be deleted.
                     .with_children(|parent| {
                         parent
-                            .spawn_bundle(("First Child, to be deleted".to_owned(), 4u32))
+                            .spawn_bundle((N("First Child, to be deleted".to_owned()), Idx(4)))
                             .with_children(|parent| {
                                 // child
                                 parent.spawn_bundle((
-                                    "First grand child, to be deleted".to_owned(),
-                                    5u32,
+                                    N("First grand child, to be deleted".to_owned()),
+                                    Idx(5),
                                 ));
                             });
-                        parent.spawn_bundle(("Second child, to be deleted".to_owned(), 6u32));
+                        parent.spawn_bundle((N("Second child, to be deleted".to_owned()), Idx(6)));
                     });
             });
 
-            commands.spawn_bundle(("An innocent bystander".to_owned(), 7u32));
+            commands.spawn_bundle((N("An innocent bystander".to_owned()), Idx(7)));
         }
         queue.apply(&mut world);
 
@@ -115,7 +124,7 @@ mod tests {
         queue.apply(&mut world);
 
         let mut results = world
-            .query::<(&String, &u32)>()
+            .query::<(&N, &Idx)>()
             .iter(&world)
             .map(|(a, b)| (a.clone(), *b))
             .collect::<Vec<_>>();
@@ -133,10 +142,10 @@ mod tests {
         assert_eq!(
             results,
             vec![
-                ("Another parent".to_owned(), 0u32),
-                ("Another child".to_owned(), 1u32),
-                ("Grandparent".to_owned(), 2u32),
-                ("An innocent bystander".to_owned(), 7u32)
+                (N("Another parent".to_owned()), Idx(0)),
+                (N("Another child".to_owned()), Idx(1)),
+                (N("Grandparent".to_owned()), Idx(2)),
+                (N("An innocent bystander".to_owned()), Idx(7))
             ]
         );
     }
diff --git a/crates/bevy_ui/src/focus.rs b/crates/bevy_ui/src/focus.rs
index 60b44c0653166..2e5acd8516062 100644
--- a/crates/bevy_ui/src/focus.rs
+++ b/crates/bevy_ui/src/focus.rs
@@ -1,6 +1,7 @@
 use crate::Node;
 use bevy_core::FloatOrd;
 use bevy_ecs::{
+    component::Component,
     entity::Entity,
     system::{Local, Query, Res},
 };
@@ -9,7 +10,7 @@ use bevy_transform::components::GlobalTransform;
 use bevy_window::Windows;
 use smallvec::SmallVec;
 
-#[derive(Copy, Clone, Eq, PartialEq, Debug)]
+#[derive(Component, Copy, Clone, Eq, PartialEq, Debug)]
 pub enum Interaction {
     Clicked,
     Hovered,
@@ -22,7 +23,7 @@ impl Default for Interaction {
     }
 }
 
-#[derive(Copy, Clone, Eq, PartialEq, Debug)]
+#[derive(Component, Copy, Clone, Eq, PartialEq, Debug)]
 pub enum FocusPolicy {
     Block,
     Pass,
diff --git a/crates/bevy_ui/src/ui_node.rs b/crates/bevy_ui/src/ui_node.rs
index 576fb8833d468..dd01542656b9c 100644
--- a/crates/bevy_ui/src/ui_node.rs
+++ b/crates/bevy_ui/src/ui_node.rs
@@ -1,11 +1,11 @@
-use bevy_ecs::reflect::ReflectComponent;
+use bevy_ecs::{component::Component, reflect::ReflectComponent};
 use bevy_math::{Rect, Size, Vec2};
 use bevy_reflect::{Reflect, ReflectDeserialize};
 use bevy_render::renderer::RenderResources;
 use serde::{Deserialize, Serialize};
 use std::ops::{Add, AddAssign};
 
-#[derive(Debug, Clone, Default, RenderResources, Reflect)]
+#[derive(Component, Debug, Clone, Default, RenderResources, Reflect)]
 #[reflect(Component)]
 pub struct Node {
     pub size: Vec2,
@@ -49,7 +49,7 @@ impl AddAssign<f32> for Val {
     }
 }
 
-#[derive(Clone, PartialEq, Debug, Reflect)]
+#[derive(Component, Clone, PartialEq, Debug, Reflect)]
 #[reflect(Component, PartialEq)]
 pub struct Style {
     pub display: Display,
@@ -251,7 +251,7 @@ impl Default for FlexWrap {
     }
 }
 
-#[derive(Default, Copy, Clone, Debug)]
+#[derive(Component, Default, Copy, Clone, Debug)]
 pub struct CalculatedSize {
     pub size: Size,
 }
diff --git a/crates/bevy_ui/src/update.rs b/crates/bevy_ui/src/update.rs
index fd3fe3690e99c..c3a27046b8d54 100644
--- a/crates/bevy_ui/src/update.rs
+++ b/crates/bevy_ui/src/update.rs
@@ -53,6 +53,7 @@ fn update_hierarchy(
 #[cfg(test)]
 mod tests {
     use bevy_ecs::{
+        component::Component,
         schedule::{Schedule, Stage, SystemStage},
         system::{CommandQueue, Commands, IntoSystem},
         world::World,
@@ -63,12 +64,15 @@ mod tests {
 
     use super::{ui_z_system, UI_Z_STEP};
 
-    fn node_with_transform(name: &str) -> (String, Node, Transform) {
-        (name.to_owned(), Node::default(), Transform::identity())
+    #[derive(Component, PartialEq, Debug, Clone)]
+    struct Label(&'static str);
+
+    fn node_with_transform(name: &'static str) -> (Label, Node, Transform) {
+        (Label(name), Node::default(), Transform::identity())
     }
 
-    fn node_without_transform(name: &str) -> (String, Node) {
-        (name.to_owned(), Node::default())
+    fn node_without_transform(name: &'static str) -> (Label, Node) {
+        (Label(name), Node::default())
     }
 
     fn get_steps(transform: &Transform) -> u32 {
@@ -127,29 +131,29 @@ mod tests {
         schedule.run(&mut world);
 
         let mut actual_result = world
-            .query::<(&String, &Transform)>()
+            .query::<(&Label, &Transform)>()
             .iter(&world)
             .map(|(name, transform)| (name.clone(), get_steps(transform)))
-            .collect::<Vec<(String, u32)>>();
-        actual_result.sort_unstable_by_key(|(name, _)| name.clone());
+            .collect::<Vec<(Label, u32)>>();
+        actual_result.sort_unstable_by_key(|(name, _)| name.0);
         let expected_result = vec![
-            ("0".to_owned(), 1),
-            ("1".to_owned(), 1),
-            ("1-0".to_owned(), 1),
-            ("1-0-0".to_owned(), 1),
+            (Label("0"), 1),
+            (Label("1"), 1),
+            (Label("1-0"), 1),
+            (Label("1-0-0"), 1),
             // 1-0-1 has no transform
-            ("1-0-2".to_owned(), 3),
-            ("1-1".to_owned(), 5),
+            (Label("1-0-2"), 3),
+            (Label("1-1"), 5),
             // 1-2 has no transform
-            ("1-2-0".to_owned(), 1),
-            ("1-2-1".to_owned(), 2),
-            ("1-2-2".to_owned(), 3),
-            ("1-2-3".to_owned(), 4),
-            ("1-3".to_owned(), 11),
+            (Label("1-2-0"), 1),
+            (Label("1-2-1"), 2),
+            (Label("1-2-2"), 3),
+            (Label("1-2-3"), 4),
+            (Label("1-3"), 11),
             // 2 has no transform
-            ("2-0".to_owned(), 1),
-            ("2-1".to_owned(), 2),
-            ("2-1-0".to_owned(), 1),
+            (Label("2-0"), 1),
+            (Label("2-1"), 2),
+            (Label("2-1-0"), 1),
         ];
         assert_eq!(actual_result, expected_result);
     }
diff --git a/crates/bevy_ui/src/widget/button.rs b/crates/bevy_ui/src/widget/button.rs
index 47baf3b6fae5d..adc58d9aafa38 100644
--- a/crates/bevy_ui/src/widget/button.rs
+++ b/crates/bevy_ui/src/widget/button.rs
@@ -1,2 +1,4 @@
-#[derive(Debug, Clone)]
+use bevy_ecs::component::Component;
+
+#[derive(Component, Debug, Clone)]
 pub struct Button;
diff --git a/crates/bevy_ui/src/widget/image.rs b/crates/bevy_ui/src/widget/image.rs
index f54e801100c70..164f417b3bb9b 100644
--- a/crates/bevy_ui/src/widget/image.rs
+++ b/crates/bevy_ui/src/widget/image.rs
@@ -1,6 +1,7 @@
 use crate::CalculatedSize;
 use bevy_asset::{Assets, Handle};
 use bevy_ecs::{
+    component::Component,
     query::With,
     system::{Query, Res},
 };
@@ -8,7 +9,7 @@ use bevy_math::Size;
 use bevy_render::texture::Texture;
 use bevy_sprite::ColorMaterial;
 
-#[derive(Debug, Clone)]
+#[derive(Component, Debug, Clone)]
 pub enum Image {
     KeepAspect,
 }
diff --git a/examples/2d/contributors.rs b/examples/2d/contributors.rs
index 74db49dc9bda8..8d613d7d58024 100644
--- a/examples/2d/contributors.rs
+++ b/examples/2d/contributors.rs
@@ -24,14 +24,18 @@ struct ContributorSelection {
     idx: usize,
 }
 
+#[derive(Component)]
 struct SelectTimer;
 
+#[derive(Component)]
 struct ContributorDisplay;
 
+#[derive(Component)]
 struct Contributor {
     hue: f32,
 }
 
+#[derive(Component)]
 struct Velocity {
     translation: Vec3,
     rotation: f32,
diff --git a/examples/2d/many_sprites.rs b/examples/2d/many_sprites.rs
index c8dbc2a8cf47b..eb79926ed1b40 100644
--- a/examples/2d/many_sprites.rs
+++ b/examples/2d/many_sprites.rs
@@ -9,7 +9,9 @@ use rand::Rng;
 
 const CAMERA_SPEED: f32 = 1000.0;
 
+#[derive(Component)]
 pub struct PrintTimer(Timer);
+#[derive(Component)]
 pub struct Position(Transform);
 
 /// This example is for performance testing purposes.
diff --git a/examples/2d/text2d.rs b/examples/2d/text2d.rs
index 86232ecab58c2..4603046fa54e2 100644
--- a/examples/2d/text2d.rs
+++ b/examples/2d/text2d.rs
@@ -10,8 +10,11 @@ fn main() {
         .run();
 }
 
+#[derive(Component)]
 struct AnimateTranslation;
+#[derive(Component)]
 struct AnimateRotation;
+#[derive(Component)]
 struct AnimateScale;
 
 fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
diff --git a/examples/3d/load_gltf.rs b/examples/3d/load_gltf.rs
index b2eae05b26d2d..93f385f6c1488 100644
--- a/examples/3d/load_gltf.rs
+++ b/examples/3d/load_gltf.rs
@@ -28,6 +28,7 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
 }
 
 /// this component indicates what entities should rotate
+#[derive(Component)]
 struct Rotates;
 
 fn rotator_system(time: Res<Time>, mut query: Query<&mut Transform, With<Rotates>>) {
diff --git a/examples/3d/parenting.rs b/examples/3d/parenting.rs
index 9891b12dda118..9491de9e079da 100644
--- a/examples/3d/parenting.rs
+++ b/examples/3d/parenting.rs
@@ -12,6 +12,7 @@ fn main() {
 }
 
 /// this component indicates what entities should rotate
+#[derive(Component)]
 struct Rotator;
 
 /// rotates the parent, which will result in the child also rotating
diff --git a/examples/3d/render_to_texture.rs b/examples/3d/render_to_texture.rs
index 2884f2c0e15b2..477d2504d0e08 100644
--- a/examples/3d/render_to_texture.rs
+++ b/examples/3d/render_to_texture.rs
@@ -19,6 +19,7 @@ use bevy::{
     window::WindowId,
 };
 
+#[derive(Component)]
 pub struct FirstPass;
 
 pub const RENDER_TEXTURE_HANDLE: HandleUntyped =
@@ -109,7 +110,9 @@ fn add_render_to_texture_graph(graph: &mut RenderGraph, size: Extent3d) {
     graph.add_node_edge("transform", FIRST_PASS).unwrap();
 }
 
+#[derive(Component)]
 struct FirstPassCube;
+#[derive(Component)]
 struct MainPassCube;
 
 /// rotates the inner cube (first pass)
diff --git a/examples/3d/update_gltf_scene.rs b/examples/3d/update_gltf_scene.rs
index c552b82727c30..aff497616b094 100644
--- a/examples/3d/update_gltf_scene.rs
+++ b/examples/3d/update_gltf_scene.rs
@@ -16,6 +16,7 @@ fn main() {
 struct SceneInstance(Option<InstanceId>);
 
 // Component that will be used to tag entities in the scene
+#[derive(Component)]
 struct EntityInMyScene;
 
 fn setup(
diff --git a/examples/3d/z_sort_debug.rs b/examples/3d/z_sort_debug.rs
index 9b094384ec790..fec8436b4f9a2 100644
--- a/examples/3d/z_sort_debug.rs
+++ b/examples/3d/z_sort_debug.rs
@@ -17,6 +17,7 @@ fn main() {
         .run();
 }
 
+#[derive(Component)]
 struct Rotator;
 
 /// rotates the parent, which will result in the child also rotating
diff --git a/examples/ecs/change_detection.rs b/examples/ecs/change_detection.rs
index 59d5d80591977..409fd404d8a99 100644
--- a/examples/ecs/change_detection.rs
+++ b/examples/ecs/change_detection.rs
@@ -12,7 +12,7 @@ fn main() {
         .run();
 }
 
-#[derive(Debug)]
+#[derive(Component, Debug)]
 struct MyComponent(f64);
 
 fn setup(mut commands: Commands) {
diff --git a/examples/ecs/ecs_guide.rs b/examples/ecs/ecs_guide.rs
index 05f5dd1a1b99e..b4e5e8543642c 100644
--- a/examples/ecs/ecs_guide.rs
+++ b/examples/ecs/ecs_guide.rs
@@ -37,11 +37,13 @@ use rand::random;
 //
 
 // Our game will have a number of "players". Each player has a name that identifies them
+#[derive(Component)]
 struct Player {
     name: String,
 }
 
 // Each player also has a score. This component holds on to that score
+#[derive(Component)]
 struct Score {
     value: usize,
 }
diff --git a/examples/ecs/iter_combinations.rs b/examples/ecs/iter_combinations.rs
index 97ed7b3280f48..642ce04597d5f 100644
--- a/examples/ecs/iter_combinations.rs
+++ b/examples/ecs/iter_combinations.rs
@@ -26,11 +26,11 @@ const GRAVITY_CONSTANT: f32 = 0.001;
 const SOFTENING: f32 = 0.01;
 const NUM_BODIES: usize = 100;
 
-#[derive(Default)]
+#[derive(Component, Default)]
 struct Mass(f32);
-#[derive(Default)]
+#[derive(Component, Default)]
 struct Acceleration(Vec3);
-#[derive(Default)]
+#[derive(Component, Default)]
 struct LastPos(Vec3);
 
 #[derive(Bundle, Default)]
diff --git a/examples/ecs/parallel_query.rs b/examples/ecs/parallel_query.rs
index 6d4ed06a4bc43..ba7cc6b3fcbd5 100644
--- a/examples/ecs/parallel_query.rs
+++ b/examples/ecs/parallel_query.rs
@@ -1,6 +1,7 @@
 use bevy::{prelude::*, tasks::prelude::*};
 use rand::random;
 
+#[derive(Component)]
 struct Velocity(Vec2);
 
 fn spawn_system(
diff --git a/examples/ecs/query_bundle.rs b/examples/ecs/query_bundle.rs
index 0691c0d849234..ac1eb1ee1352f 100644
--- a/examples/ecs/query_bundle.rs
+++ b/examples/ecs/query_bundle.rs
@@ -12,10 +12,10 @@ fn main() {
 #[derive(Debug, Hash, PartialEq, Eq, Clone, SystemLabel)]
 struct LogNamesSystem;
 
-#[derive(Debug)]
+#[derive(Component, Debug)]
 struct Name(String);
 
-#[derive(Debug)]
+#[derive(Component, Debug)]
 struct Age(usize);
 
 #[derive(Debug, Bundle)]
diff --git a/examples/ecs/removal_detection.rs b/examples/ecs/removal_detection.rs
index 662c96babffd0..0fc683500e7b0 100644
--- a/examples/ecs/removal_detection.rs
+++ b/examples/ecs/removal_detection.rs
@@ -23,6 +23,7 @@ fn main() {
 
 // This `Struct` is just used for convenience in this example. This is the `Component` we'll be
 // giving to the `Entity` so we have a `Component` to remove in `remove_component()`.
+#[derive(Component)]
 struct MyComponent;
 
 fn setup(
diff --git a/examples/ecs/system_param.rs b/examples/ecs/system_param.rs
index 97baba11f414c..a15aa8b3082f3 100644
--- a/examples/ecs/system_param.rs
+++ b/examples/ecs/system_param.rs
@@ -9,7 +9,9 @@ fn main() {
         .run();
 }
 
+#[derive(Component)]
 pub struct Player;
+#[derive(Component)]
 pub struct PlayerCount(usize);
 
 /// The SystemParam struct can contain any types that can also be included in a
diff --git a/examples/game/breakout.rs b/examples/game/breakout.rs
index 549faa64ac558..51da690b48acc 100644
--- a/examples/game/breakout.rs
+++ b/examples/game/breakout.rs
@@ -25,24 +25,27 @@ fn main() {
         .run();
 }
 
+#[derive(Component)]
 struct Paddle {
     speed: f32,
 }
 
+#[derive(Component)]
 struct Ball {
     velocity: Vec3,
 }
 
-struct Scoreboard {
-    score: usize,
-}
-
+#[derive(Component)]
 enum Collider {
     Solid,
     Scorable,
     Paddle,
 }
 
+struct Scoreboard {
+    score: usize,
+}
+
 fn setup(
     mut commands: Commands,
     mut materials: ResMut<Assets<ColorMaterial>>,
diff --git a/examples/scene/scene.rs b/examples/scene/scene.rs
index 1afeb9c1443f5..e0d092eed7d26 100644
--- a/examples/scene/scene.rs
+++ b/examples/scene/scene.rs
@@ -19,7 +19,7 @@ fn main() {
 // example. The `FromResources` trait determines how your component is constructed when it loads.
 // For simple use cases you can just implement the `Default` trait (which automatically implements
 // FromResources). The simplest registered component just needs these two derives:
-#[derive(Reflect, Default)]
+#[derive(Component, Reflect, Default)]
 #[reflect(Component)] // this tells the reflect derive to also reflect component behaviors
 struct ComponentA {
     pub x: f32,
@@ -30,7 +30,7 @@ struct ComponentA {
 // ignored with the #[reflect(ignore)] attribute. This is also generally where the `FromResources`
 // trait comes into play. `FromResources` gives you access to your App's current ECS `Resources`
 // when you construct your component.
-#[derive(Reflect)]
+#[derive(Component, Reflect)]
 #[reflect(Component)]
 struct ComponentB {
     pub value: String,
diff --git a/examples/shader/animate_shader.rs b/examples/shader/animate_shader.rs
index bcc8a478b4046..8f6f10b2ae9d7 100644
--- a/examples/shader/animate_shader.rs
+++ b/examples/shader/animate_shader.rs
@@ -20,7 +20,7 @@ pub fn main() {
         .run();
 }
 
-#[derive(RenderResources, Default, TypeUuid)]
+#[derive(Component, RenderResources, Default, TypeUuid)]
 #[uuid = "463e4b8a-d555-4fc2-ba9f-4c880063ba92"]
 struct TimeUniform {
     value: f32,
diff --git a/examples/shader/array_texture.rs b/examples/shader/array_texture.rs
index 8f42f78a1dcf1..9f11f5c1c8ad9 100644
--- a/examples/shader/array_texture.rs
+++ b/examples/shader/array_texture.rs
@@ -21,7 +21,7 @@ fn main() {
         .run();
 }
 
-#[derive(RenderResources, Default, TypeUuid)]
+#[derive(Component, RenderResources, Default, TypeUuid)]
 #[uuid = "93fb26fc-6c05-489b-9029-601edf703b6b"]
 struct MyArrayTexture {
     pub texture: Handle<Texture>,
diff --git a/examples/tools/bevymark.rs b/examples/tools/bevymark.rs
index 258c4715408e7..44c157f7f0c24 100644
--- a/examples/tools/bevymark.rs
+++ b/examples/tools/bevymark.rs
@@ -15,6 +15,7 @@ struct BevyCounter {
     pub count: u128,
 }
 
+#[derive(Component)]
 struct Bird {
     velocity: Vec3,
 }
diff --git a/examples/ui/text.rs b/examples/ui/text.rs
index 54ca621cd02f7..c933cbb250b36 100644
--- a/examples/ui/text.rs
+++ b/examples/ui/text.rs
@@ -17,9 +17,11 @@ fn main() {
 }
 
 // A unit struct to help identify the FPS UI component, since there may be many Text components
+#[derive(Component)]
 struct FpsText;
 
 // A unit struct to help identify the color-changing Text component
+#[derive(Component)]
 struct ColorText;
 
 fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
diff --git a/examples/ui/text_debug.rs b/examples/ui/text_debug.rs
index 418bb608b3417..7b698f3410888 100644
--- a/examples/ui/text_debug.rs
+++ b/examples/ui/text_debug.rs
@@ -17,6 +17,7 @@ fn main() {
         .run();
 }
 
+#[derive(Component)]
 struct TextChanges;
 
 fn infotext_system(mut commands: Commands, asset_server: Res<AssetServer>) {
diff --git a/tests/how_to_test_systems.rs b/tests/how_to_test_systems.rs
index b70807aafa964..27baf4127e986 100644
--- a/tests/how_to_test_systems.rs
+++ b/tests/how_to_test_systems.rs
@@ -1,6 +1,6 @@
 use bevy::prelude::*;
 
-#[derive(Default)]
+#[derive(Component, Default)]
 struct Enemy {
     hit_points: u32,
 }

From 8f615ed5212b1686f3507777139fdc3392ac241b Mon Sep 17 00:00:00 2001
From: Frizi <frizi09@gmail.com>
Date: Tue, 25 May 2021 23:21:36 +0200
Subject: [PATCH 02/22] use dedicated blanket trait for state data

---
 crates/bevy_app/src/app_builder.rs         |  8 ++++----
 crates/bevy_ecs/src/schedule/state.rs      | 24 +++++++++++-----------
 crates/bevy_ecs/src/schedule/system_set.rs | 24 +++++++++-------------
 3 files changed, 26 insertions(+), 30 deletions(-)

diff --git a/crates/bevy_app/src/app_builder.rs b/crates/bevy_app/src/app_builder.rs
index 58bf336223d06..e29fb9e8312f6 100644
--- a/crates/bevy_app/src/app_builder.rs
+++ b/crates/bevy_app/src/app_builder.rs
@@ -7,13 +7,13 @@ use bevy_ecs::{
     component::ComponentDescriptor,
     event::Events,
     schedule::{
-        RunOnce, Schedule, Stage, StageLabel, State, SystemDescriptor, SystemSet, SystemStage,
+        RunOnce, Schedule, Stage, StageLabel, State, StateData, SystemDescriptor, SystemSet,
+        SystemStage,
     },
     system::{IntoExclusiveSystem, IntoSystem, Resource},
     world::{FromWorld, World},
 };
 use bevy_utils::tracing::debug;
-use std::{fmt::Debug, hash::Hash};
 
 /// Configure [App]s using the builder pattern
 pub struct AppBuilder {
@@ -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: Resource + Debug + Clone + Eq + Hash,
+        T: StateData,
     {
         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: Resource + Debug + Clone + Eq + Hash,
+        T: StateData,
     {
         self.insert_resource(State::new(initial))
             .add_system_set_to_stage(stage, State::<T>::get_driver())
diff --git a/crates/bevy_ecs/src/schedule/state.rs b/crates/bevy_ecs/src/schedule/state.rs
index b90f128bc2d64..ee154c04739bb 100644
--- a/crates/bevy_ecs/src/schedule/state.rs
+++ b/crates/bevy_ecs/src/schedule/state.rs
@@ -3,11 +3,14 @@ use crate::{
         RunCriteriaDescriptor, RunCriteriaDescriptorCoercion, RunCriteriaLabel, ShouldRun,
         SystemSet,
     },
-    system::{In, IntoChainSystem, IntoSystem, Local, Res, ResMut, Resource},
+    system::{In, IntoChainSystem, IntoSystem, Local, Res, ResMut},
 };
 use std::{any::TypeId, fmt::Debug, hash::Hash};
 use thiserror::Error;
 
+pub trait StateData: Send + Sync + Clone + Eq + Debug + Hash + 'static {}
+impl<T> StateData for T where T: Send + Sync + Clone + Eq + Debug + Hash + 'static {}
+
 /// ### Stack based state machine
 ///
 /// This state machine has four operations: Push, Pop, Set and Replace.
@@ -16,7 +19,7 @@ use thiserror::Error;
 /// * Set replaces the active state with a new one
 /// * Replace unwinds the state stack, and replaces the entire stack with a single new state
 #[derive(Debug)]
-pub struct State<T: Resource + Clone + Eq> {
+pub struct State<T: StateData> {
     transition: Option<StateTransition<T>>,
     stack: Vec<T>,
     scheduled: Option<ScheduledOperation<T>>,
@@ -24,7 +27,7 @@ pub struct State<T: Resource + Clone + Eq> {
 }
 
 #[derive(Debug)]
-enum StateTransition<T: Resource + Clone + Eq> {
+enum StateTransition<T: StateData> {
     PreStartup,
     Startup,
     // The parameter order is always (leaving, entering)
@@ -36,7 +39,7 @@ enum StateTransition<T: Resource + Clone + Eq> {
 }
 
 #[derive(Debug)]
-enum ScheduledOperation<T: Resource + Clone + Eq> {
+enum ScheduledOperation<T: StateData> {
     Set(T),
     Replace(T),
     Pop,
@@ -57,7 +60,7 @@ enum StateCallback {
 impl StateCallback {
     fn into_label<T>(self, state: T) -> StateRunCriteriaLabel<T>
     where
-        T: Resource + Debug + Clone + Eq + Hash,
+        T: StateData,
     {
         StateRunCriteriaLabel(state, self)
     }
@@ -67,7 +70,7 @@ impl StateCallback {
 struct StateRunCriteriaLabel<T>(T, StateCallback);
 impl<T> RunCriteriaLabel for StateRunCriteriaLabel<T>
 where
-    T: Resource + Debug + Clone + Eq + Hash,
+    T: StateData,
 {
     fn dyn_clone(&self) -> Box<dyn RunCriteriaLabel> {
         Box::new(self.clone())
@@ -90,7 +93,7 @@ impl DriverLabel {
 
 impl<T> State<T>
 where
-    T: Resource + Debug + Clone + Eq + Hash,
+    T: StateData,
 {
     pub fn on_update(s: T) -> RunCriteriaDescriptor {
         (|state: Res<State<T>>, pred: Local<Option<T>>| {
@@ -393,10 +396,7 @@ pub enum StateError {
     StackEmpty,
 }
 
-fn should_run_adapter<T: Resource + Clone + Eq>(
-    In(cmp_result): In<bool>,
-    state: Res<State<T>>,
-) -> ShouldRun {
+fn should_run_adapter<T: StateData>(In(cmp_result): In<bool>, state: Res<State<T>>) -> ShouldRun {
     if state.end_next_loop {
         return ShouldRun::No;
     }
@@ -407,7 +407,7 @@ fn should_run_adapter<T: Resource + Clone + Eq>(
     }
 }
 
-fn state_cleaner<T: Resource + Clone + Eq>(
+fn state_cleaner<T: StateData>(
     mut state: ResMut<State<T>>,
     mut prep_exit: Local<bool>,
 ) -> ShouldRun {
diff --git a/crates/bevy_ecs/src/schedule/system_set.rs b/crates/bevy_ecs/src/schedule/system_set.rs
index 6748b34775d83..b04b2a7c2a4bc 100644
--- a/crates/bevy_ecs/src/schedule/system_set.rs
+++ b/crates/bevy_ecs/src/schedule/system_set.rs
@@ -1,11 +1,7 @@
-use crate::{
-    schedule::{
-        AmbiguitySetLabel, BoxedAmbiguitySetLabel, BoxedSystemLabel, IntoRunCriteria,
-        RunCriteriaDescriptorOrLabel, State, SystemDescriptor, SystemLabel,
-    },
-    system::Resource,
+use crate::schedule::{
+    AmbiguitySetLabel, BoxedAmbiguitySetLabel, BoxedSystemLabel, IntoRunCriteria,
+    RunCriteriaDescriptorOrLabel, State, StateData, SystemDescriptor, SystemLabel,
 };
-use std::{fmt::Debug, hash::Hash};
 
 /// A builder for describing several systems at the same time.
 pub struct SystemSet {
@@ -37,49 +33,49 @@ impl SystemSet {
 
     pub fn on_update<T>(s: T) -> SystemSet
     where
-        T: Resource + Debug + Clone + Eq + Hash,
+        T: StateData,
     {
         Self::new().with_run_criteria(State::<T>::on_update(s))
     }
 
     pub fn on_inactive_update<T>(s: T) -> SystemSet
     where
-        T: Resource + Debug + Clone + Eq + Hash,
+        T: StateData,
     {
         Self::new().with_run_criteria(State::<T>::on_inactive_update(s))
     }
 
     pub fn on_in_stack_update<T>(s: T) -> SystemSet
     where
-        T: Resource + Debug + Clone + Eq + Hash,
+        T: StateData,
     {
         Self::new().with_run_criteria(State::<T>::on_in_stack_update(s))
     }
 
     pub fn on_enter<T>(s: T) -> SystemSet
     where
-        T: Resource + Debug + Clone + Eq + Hash,
+        T: StateData,
     {
         Self::new().with_run_criteria(State::<T>::on_enter(s))
     }
 
     pub fn on_exit<T>(s: T) -> SystemSet
     where
-        T: Resource + Debug + Clone + Eq + Hash,
+        T: StateData,
     {
         Self::new().with_run_criteria(State::<T>::on_exit(s))
     }
 
     pub fn on_pause<T>(s: T) -> SystemSet
     where
-        T: Resource + Debug + Clone + Eq + Hash,
+        T: StateData,
     {
         Self::new().with_run_criteria(State::<T>::on_pause(s))
     }
 
     pub fn on_resume<T>(s: T) -> SystemSet
     where
-        T: Resource + Debug + Clone + Eq + Hash,
+        T: StateData,
     {
         Self::new().with_run_criteria(State::<T>::on_resume(s))
     }

From 078150f66ffd5d811ef505ca2ffce2cd9d371fe9 Mon Sep 17 00:00:00 2001
From: Frizi <frizi09@gmail.com>
Date: Wed, 26 May 2021 00:32:36 +0200
Subject: [PATCH 03/22] add doc comment about newtype component

---
 crates/bevy_ecs/src/component/mod.rs | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/crates/bevy_ecs/src/component/mod.rs b/crates/bevy_ecs/src/component/mod.rs
index d3cd8c38c56b3..9ca8e17ff839b 100644
--- a/crates/bevy_ecs/src/component/mod.rs
+++ b/crates/bevy_ecs/src/component/mod.rs
@@ -16,6 +16,13 @@ use thiserror::Error;
 ///
 /// Any type that is `Send + Sync + 'static` can implement `Component` using `#[derive(Component)]`.
 ///
+/// In order to use foreign types as components, wrap them using a newtype pattern.
+/// ```
+/// # use bevy_ecs::component::Component;
+/// use std::time::Duration;
+/// #[derive(Component)]
+/// struct Cooldown(Duration);
+/// ```
 /// Components are added with new entities using [`Commands::spawn`](crate::system::Commands::spawn),
 /// or to existing entities with [`EntityCommands::insert`](crate::system::EntityCommands::insert),
 /// or their [`World`](crate::world::World) equivalents.

From aafa863558b01e620de3699f91005f0c36da3c00 Mon Sep 17 00:00:00 2001
From: Frizi <frizi09@gmail.com>
Date: Sat, 5 Jun 2021 12:48:29 +0200
Subject: [PATCH 04/22] add missing derives in new tests

---
 crates/bevy_ecs/src/system/mod.rs | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/crates/bevy_ecs/src/system/mod.rs b/crates/bevy_ecs/src/system/mod.rs
index c5b40466fecc2..d70f9d90c50b5 100644
--- a/crates/bevy_ecs/src/system/mod.rs
+++ b/crates/bevy_ecs/src/system/mod.rs
@@ -521,7 +521,7 @@ mod tests {
         #[derive(Eq, PartialEq, Debug)]
         struct A(usize);
 
-        #[derive(Eq, PartialEq, Debug)]
+        #[derive(Component, Eq, PartialEq, Debug)]
         struct B(usize);
 
         let mut world = World::default();
@@ -544,7 +544,7 @@ mod tests {
         #[derive(Eq, PartialEq, Debug)]
         struct A(usize);
 
-        #[derive(Eq, PartialEq, Debug)]
+        #[derive(Component, Eq, PartialEq, Debug)]
         struct B(usize);
 
         let mut world = World::default();
@@ -568,7 +568,7 @@ mod tests {
 
     #[test]
     fn system_state_change_detection() {
-        #[derive(Eq, PartialEq, Debug)]
+        #[derive(Component, Eq, PartialEq, Debug)]
         struct A(usize);
 
         let mut world = World::default();
@@ -603,10 +603,10 @@ mod tests {
 
     #[test]
     fn system_state_archetype_update() {
-        #[derive(Eq, PartialEq, Debug)]
+        #[derive(Component, Eq, PartialEq, Debug)]
         struct A(usize);
 
-        #[derive(Eq, PartialEq, Debug)]
+        #[derive(Component, Eq, PartialEq, Debug)]
         struct B(usize);
 
         let mut world = World::default();

From c529535b5f0dd6305798e2d4ee84af44ffbb0891 Mon Sep 17 00:00:00 2001
From: Frizi <frizi09@gmail.com>
Date: Wed, 9 Jun 2021 17:12:18 +0200
Subject: [PATCH 05/22] statically defined storage type

---
 Cargo.toml                              |  2 +-
 crates/bevy_ecs/macros/src/component.rs | 38 ++++++++++++-
 crates/bevy_ecs/macros/src/lib.rs       | 17 +++++-
 crates/bevy_ecs/src/bundle.rs           | 11 +++-
 crates/bevy_ecs/src/component/mod.rs    | 74 ++++++++++++++++++++-----
 crates/bevy_ecs/src/query/fetch.rs      | 40 +++++--------
 crates/bevy_ecs/src/query/filter.rs     | 33 +++--------
 crates/bevy_ecs/src/query/iter.rs       | 13 ++---
 crates/bevy_ecs/src/system/commands.rs  | 11 ++--
 crates/bevy_render/src/draw.rs          |  1 +
 crates/bevy_sprite/src/lib.rs           |  7 ---
 11 files changed, 154 insertions(+), 93 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 9e8551ffc3daf..d282dd6d9b5a3 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -45,7 +45,7 @@ bevy_audio = ["bevy_internal/bevy_audio"]
 bevy_dynamic_plugin = ["bevy_internal/bevy_dynamic_plugin"]
 bevy_gilrs = ["bevy_internal/bevy_gilrs"]
 bevy_gltf = ["bevy_internal/bevy_gltf"]
-bevy_wgpu = ["bevy_internal/bevy_wgpu"]
+bevy_wgpu = ["bevy_internal/bevy_wgpu"] 
 bevy_winit = ["bevy_internal/bevy_winit"]
 
 trace_chrome = ["bevy_internal/trace_chrome"]
diff --git a/crates/bevy_ecs/macros/src/component.rs b/crates/bevy_ecs/macros/src/component.rs
index e0aae6e6b7f83..e69c31f43a333 100644
--- a/crates/bevy_ecs/macros/src/component.rs
+++ b/crates/bevy_ecs/macros/src/component.rs
@@ -1,11 +1,20 @@
 use proc_macro::TokenStream;
+use proc_macro2::{Span, TokenStream as TokenStream2};
 use quote::quote;
-use syn::{parse_macro_input, parse_quote, DeriveInput, Path};
+use syn::{parse_macro_input, parse_quote, Attribute, DeriveInput, Error, Ident, Path, Result};
 
 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();
 
+    let storage = ast
+        .attrs
+        .iter()
+        .find(|attr| attr.path.is_ident("storage"))
+        .map_or(Ok(StorageTy::Table), parse_storage_attribute)
+        .map(|ty| storage_path(bevy_ecs_path.clone(), ty))
+        .unwrap_or_else(|err| err.to_compile_error());
+
     ast.generics
         .make_where_clause()
         .predicates
@@ -15,6 +24,31 @@ pub fn derive_component(input: TokenStream) -> TokenStream {
     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 {}
+        impl #impl_generics #bevy_ecs_path::component::Component for #struct_name #type_generics #where_clause {
+            type Storage = #storage;
+        }
     })
 }
+
+enum StorageTy {
+    Table,
+    Sparse,
+}
+
+fn parse_storage_attribute(attr: &Attribute) -> Result<StorageTy> {
+    let ident = attr.parse_args::<Ident>()?;
+    match ident.to_string().as_str() {
+        "table" => Ok(StorageTy::Table),
+        "sparse" => Ok(StorageTy::Sparse),
+        _ => Err(Error::new(ident.span(), "Invalid storage type, expected 'table' or 'sparse'.")),
+    }
+}
+
+fn storage_path(bevy_ecs_path: Path, ty: StorageTy) -> TokenStream2 {
+    let typename = match ty {
+        StorageTy::Table => Ident::new("TableStorage", Span::call_site()),
+        StorageTy::Sparse => Ident::new("SparseStorage", Span::call_site()),
+    };
+
+    quote! { #bevy_ecs_path::component::#typename }
+}
diff --git a/crates/bevy_ecs/macros/src/lib.rs b/crates/bevy_ecs/macros/src/lib.rs
index 2de0b9e22762b..a2efa81d2aee3 100644
--- a/crates/bevy_ecs/macros/src/lib.rs
+++ b/crates/bevy_ecs/macros/src/lib.rs
@@ -115,6 +115,8 @@ pub fn derive_bundle(input: TokenStream) -> TokenStream {
     let mut field_type_infos = Vec::new();
     let mut field_get_components = Vec::new();
     let mut field_from_components = Vec::new();
+    let mut is_dense_const_exprs = Vec::new();
+    let mut is_dense_fn_exprs = Vec::new();
     for ((field_type, is_bundle), field) in
         field_type.iter().zip(is_bundle.iter()).zip(field.iter())
     {
@@ -128,6 +130,9 @@ pub fn derive_bundle(input: TokenStream) -> TokenStream {
             field_from_components.push(quote! {
                 #field: <#field_type as #ecs_path::bundle::Bundle>::from_components(&mut func),
             });
+            is_dense_fn_exprs.push(quote! {
+                <#field_type as #ecs_path::bundle::Bundle>::is_dense()
+            });
         } else {
             field_type_infos.push(quote! {
                 type_info.push(#ecs_path::component::TypeInfo::of::<#field_type>());
@@ -139,6 +144,10 @@ pub fn derive_bundle(input: TokenStream) -> TokenStream {
             field_from_components.push(quote! {
                 #field: func().cast::<#field_type>().read(),
             });
+            is_dense_const_exprs.push(quote! {
+                <<#field_type as #ecs_path::component::Component>::Storage as #ecs_path::component::ComponentStorage>::STORAGE_TYPE
+                    == #ecs_path::component::StorageType::Table
+            });
         }
     }
     let field_len = field.len();
@@ -155,6 +164,12 @@ pub fn derive_bundle(input: TokenStream) -> TokenStream {
                 type_info
             }
 
+            #[inline(always)]
+            fn is_dense() -> bool {
+                // insert const expressions in front to avoid evaluating non-const functions if possible
+                true #(&& (#is_dense_const_exprs))* #(&& #is_dense_fn_exprs)*
+            }
+
             #[allow(unused_variables, unused_mut, non_snake_case)]
             unsafe fn from_components(mut func: impl FnMut() -> *mut u8) -> Self {
                 Self {
@@ -481,7 +496,7 @@ pub(crate) fn bevy_ecs_path() -> syn::Path {
     BevyManifest::default().get_path("bevy_ecs")
 }
 
-#[proc_macro_derive(Component)]
+#[proc_macro_derive(Component, attributes(storage))]
 pub fn derive_component(input: TokenStream) -> TokenStream {
     component::derive_component(input)
 }
diff --git a/crates/bevy_ecs/src/bundle.rs b/crates/bevy_ecs/src/bundle.rs
index 00f3bac9e527e..9b2791b42ea7e 100644
--- a/crates/bevy_ecs/src/bundle.rs
+++ b/crates/bevy_ecs/src/bundle.rs
@@ -2,7 +2,9 @@ pub use bevy_ecs_macros::Bundle;
 
 use crate::{
     archetype::ComponentStatus,
-    component::{Component, ComponentId, ComponentTicks, Components, StorageType, TypeInfo},
+    component::{
+        Component, ComponentId, ComponentStorage, ComponentTicks, Components, StorageType, TypeInfo,
+    },
     entity::Entity,
     storage::{SparseSetIndex, SparseSets, Table},
 };
@@ -60,6 +62,8 @@ pub unsafe trait Bundle: Send + Sync + 'static {
     /// "mem::forget" the bundle fields, so callers are responsible for dropping the fields if
     /// that is desirable.
     fn get_components(self, func: impl FnMut(*mut u8));
+
+    fn is_dense() -> bool;
 }
 
 macro_rules! tuple_impl {
@@ -70,6 +74,11 @@ macro_rules! tuple_impl {
                 vec![$(TypeInfo::of::<$name>()),*]
             }
 
+            #[inline(always)]
+            fn is_dense() -> bool {
+                true $(&& $name::Storage::STORAGE_TYPE == StorageType::Table)*
+            }
+
             #[allow(unused_variables, unused_mut)]
             unsafe fn from_components(mut func: impl FnMut() -> *mut u8) -> Self {
                 #[allow(non_snake_case)]
diff --git a/crates/bevy_ecs/src/component/mod.rs b/crates/bevy_ecs/src/component/mod.rs
index 9ca8e17ff839b..df55ca1936d14 100644
--- a/crates/bevy_ecs/src/component/mod.rs
+++ b/crates/bevy_ecs/src/component/mod.rs
@@ -31,26 +31,72 @@ use thiserror::Error;
 /// 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 + Sync + 'static {
+    type Storage: ComponentStorage;
+}
+
+pub struct TableStorage;
+pub struct SparseStorage;
+
+pub trait ComponentStorage: sealed::Sealed {
+    // because the trait is selaed, those items are private API.
+    const STORAGE_TYPE: StorageType;
+}
+
+impl ComponentStorage for TableStorage {
+    const STORAGE_TYPE: StorageType = StorageType::Table;
+}
+impl ComponentStorage for SparseStorage {
+    const STORAGE_TYPE: StorageType = StorageType::SparseSet;
+}
+
+mod sealed {
+    pub trait Sealed {}
+    impl Sealed for super::TableStorage {}
+    impl Sealed for super::SparseStorage {}
+}
 
 // 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 {}
+impl<T> Component for bevy_tasks::Task<T>
+where
+    Self: Send + Sync + 'static,
+{
+    type Storage = TableStorage;
+}
 
 // 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 {}
+    use super::{Component, TableStorage};
+    impl Component for &'static str {
+        type Storage = TableStorage;
+    }
+    impl Component for usize {
+        type Storage = TableStorage;
+    }
+    impl Component for i32 {
+        type Storage = TableStorage;
+    }
+    impl Component for u32 {
+        type Storage = TableStorage;
+    }
+    impl Component for u64 {
+        type Storage = TableStorage;
+    }
+    impl Component for f32 {
+        type Storage = TableStorage;
+    }
+    impl Component for f64 {
+        type Storage = TableStorage;
+    }
+    impl Component for u8 {
+        type Storage = TableStorage;
+    }
+    impl Component for bool {
+        type Storage = TableStorage;
+    }
 }
 
 #[derive(Debug, Copy, Clone, Eq, PartialEq)]
@@ -165,10 +211,10 @@ pub struct ComponentDescriptor {
 }
 
 impl ComponentDescriptor {
-    pub fn new<T: Component>(storage_type: StorageType) -> Self {
+    pub fn new<T: Component>(_storage_type: StorageType) -> Self {
         Self {
             name: std::any::type_name::<T>().to_string(),
-            storage_type,
+            storage_type: T::Storage::STORAGE_TYPE,
             is_send_and_sync: true,
             type_id: Some(TypeId::of::<T>()),
             layout: Layout::new::<T>(),
diff --git a/crates/bevy_ecs/src/query/fetch.rs b/crates/bevy_ecs/src/query/fetch.rs
index 39d411e332b9c..b4a197126c4be 100644
--- a/crates/bevy_ecs/src/query/fetch.rs
+++ b/crates/bevy_ecs/src/query/fetch.rs
@@ -1,7 +1,7 @@
 use crate::{
     archetype::{Archetype, ArchetypeComponentId},
     change_detection::Ticks,
-    component::{Component, ComponentId, ComponentTicks, StorageType},
+    component::{Component, ComponentId, ComponentStorage, ComponentTicks, StorageType},
     entity::Entity,
     query::{Access, FilteredAccess},
     storage::{ComponentSparseSet, Table, Tables},
@@ -227,7 +227,6 @@ impl<T: Component> WorldQuery for &T {
 /// The [`FetchState`] of `&T`.
 pub struct ReadState<T> {
     component_id: ComponentId,
-    storage_type: StorageType,
     marker: PhantomData<T>,
 }
 
@@ -238,7 +237,6 @@ unsafe impl<T: Component> FetchState for ReadState<T> {
         let component_info = world.components.get_or_insert_info::<T>();
         ReadState {
             component_id: component_info.id(),
-            storage_type: component_info.storage_type(),
             marker: PhantomData,
         }
     }
@@ -274,7 +272,6 @@ unsafe impl<T: Component> FetchState for ReadState<T> {
 
 /// The [`Fetch`] of `&T`.
 pub struct ReadFetch<T> {
-    storage_type: StorageType,
     table_components: NonNull<T>,
     entity_table_rows: *const usize,
     entities: *const Entity,
@@ -284,7 +281,6 @@ pub struct ReadFetch<T> {
 impl<T> Clone for ReadFetch<T> {
     fn clone(&self) -> Self {
         Self {
-            storage_type: self.storage_type,
             table_components: self.table_components,
             entity_table_rows: self.entity_table_rows,
             entities: self.entities,
@@ -302,7 +298,7 @@ impl<'w, T: Component> Fetch<'w> for ReadFetch<T> {
 
     #[inline]
     fn is_dense(&self) -> bool {
-        match self.storage_type {
+        match T::Storage::STORAGE_TYPE {
             StorageType::Table => true,
             StorageType::SparseSet => false,
         }
@@ -315,13 +311,12 @@ impl<'w, T: Component> Fetch<'w> for ReadFetch<T> {
         _change_tick: u32,
     ) -> Self {
         let mut value = Self {
-            storage_type: state.storage_type,
             table_components: NonNull::dangling(),
             entities: ptr::null::<Entity>(),
             entity_table_rows: ptr::null::<usize>(),
             sparse_set: ptr::null::<ComponentSparseSet>(),
         };
-        if state.storage_type == StorageType::SparseSet {
+        if T::Storage::STORAGE_TYPE == StorageType::SparseSet {
             value.sparse_set = world
                 .storages()
                 .sparse_sets
@@ -338,7 +333,7 @@ impl<'w, T: Component> Fetch<'w> for ReadFetch<T> {
         archetype: &Archetype,
         tables: &Tables,
     ) {
-        match state.storage_type {
+        match T::Storage::STORAGE_TYPE {
             StorageType::Table => {
                 self.entity_table_rows = archetype.entity_table_rows().as_ptr();
                 let column = tables[archetype.table_id()]
@@ -361,7 +356,7 @@ impl<'w, T: Component> Fetch<'w> for ReadFetch<T> {
 
     #[inline]
     unsafe fn archetype_fetch(&mut self, archetype_index: usize) -> Self::Item {
-        match self.storage_type {
+        match T::Storage::STORAGE_TYPE {
             StorageType::Table => {
                 let table_row = *self.entity_table_rows.add(archetype_index);
                 &*self.table_components.as_ptr().add(table_row)
@@ -386,7 +381,6 @@ impl<T: Component> WorldQuery for &mut T {
 
 /// The [`Fetch`] of `&mut T`.
 pub struct WriteFetch<T> {
-    storage_type: StorageType,
     table_components: NonNull<T>,
     table_ticks: *const UnsafeCell<ComponentTicks>,
     entities: *const Entity,
@@ -399,7 +393,6 @@ pub struct WriteFetch<T> {
 impl<T> Clone for WriteFetch<T> {
     fn clone(&self) -> Self {
         Self {
-            storage_type: self.storage_type,
             table_components: self.table_components,
             table_ticks: self.table_ticks,
             entities: self.entities,
@@ -414,7 +407,6 @@ impl<T> Clone for WriteFetch<T> {
 /// The [`FetchState`] of `&mut T`.
 pub struct WriteState<T> {
     component_id: ComponentId,
-    storage_type: StorageType,
     marker: PhantomData<T>,
 }
 
@@ -425,7 +417,6 @@ unsafe impl<T: Component> FetchState for WriteState<T> {
         let component_info = world.components.get_or_insert_info::<T>();
         WriteState {
             component_id: component_info.id(),
-            storage_type: component_info.storage_type(),
             marker: PhantomData,
         }
     }
@@ -465,7 +456,7 @@ impl<'w, T: Component> Fetch<'w> for WriteFetch<T> {
 
     #[inline]
     fn is_dense(&self) -> bool {
-        match self.storage_type {
+        match T::Storage::STORAGE_TYPE {
             StorageType::Table => true,
             StorageType::SparseSet => false,
         }
@@ -478,7 +469,6 @@ impl<'w, T: Component> Fetch<'w> for WriteFetch<T> {
         change_tick: u32,
     ) -> Self {
         let mut value = Self {
-            storage_type: state.storage_type,
             table_components: NonNull::dangling(),
             entities: ptr::null::<Entity>(),
             entity_table_rows: ptr::null::<usize>(),
@@ -487,7 +477,7 @@ impl<'w, T: Component> Fetch<'w> for WriteFetch<T> {
             last_change_tick,
             change_tick,
         };
-        if state.storage_type == StorageType::SparseSet {
+        if T::Storage::STORAGE_TYPE == StorageType::SparseSet {
             value.sparse_set = world
                 .storages()
                 .sparse_sets
@@ -504,7 +494,7 @@ impl<'w, T: Component> Fetch<'w> for WriteFetch<T> {
         archetype: &Archetype,
         tables: &Tables,
     ) {
-        match state.storage_type {
+        match T::Storage::STORAGE_TYPE {
             StorageType::Table => {
                 self.entity_table_rows = archetype.entity_table_rows().as_ptr();
                 let column = tables[archetype.table_id()]
@@ -526,7 +516,7 @@ impl<'w, T: Component> Fetch<'w> for WriteFetch<T> {
 
     #[inline]
     unsafe fn archetype_fetch(&mut self, archetype_index: usize) -> Self::Item {
-        match self.storage_type {
+        match T::Storage::STORAGE_TYPE {
             StorageType::Table => {
                 let table_row = *self.entity_table_rows.add(archetype_index);
                 Mut {
@@ -752,7 +742,6 @@ impl<T: Component> WorldQuery for ChangeTrackers<T> {
 /// The [`FetchState`] of [`ChangeTrackers`].
 pub struct ChangeTrackersState<T> {
     component_id: ComponentId,
-    storage_type: StorageType,
     marker: PhantomData<T>,
 }
 
@@ -763,7 +752,6 @@ unsafe impl<T: Component> FetchState for ChangeTrackersState<T> {
         let component_info = world.components.get_or_insert_info::<T>();
         Self {
             component_id: component_info.id(),
-            storage_type: component_info.storage_type(),
             marker: PhantomData,
         }
     }
@@ -799,7 +787,6 @@ unsafe impl<T: Component> FetchState for ChangeTrackersState<T> {
 
 /// The [`Fetch`] of [`ChangeTrackers`].
 pub struct ChangeTrackersFetch<T> {
-    storage_type: StorageType,
     table_ticks: *const ComponentTicks,
     entity_table_rows: *const usize,
     entities: *const Entity,
@@ -818,7 +805,7 @@ impl<'w, T: Component> Fetch<'w> for ChangeTrackersFetch<T> {
 
     #[inline]
     fn is_dense(&self) -> bool {
-        match self.storage_type {
+        match T::Storage::STORAGE_TYPE {
             StorageType::Table => true,
             StorageType::SparseSet => false,
         }
@@ -831,7 +818,6 @@ impl<'w, T: Component> Fetch<'w> for ChangeTrackersFetch<T> {
         change_tick: u32,
     ) -> Self {
         let mut value = Self {
-            storage_type: state.storage_type,
             table_ticks: ptr::null::<ComponentTicks>(),
             entities: ptr::null::<Entity>(),
             entity_table_rows: ptr::null::<usize>(),
@@ -840,7 +826,7 @@ impl<'w, T: Component> Fetch<'w> for ChangeTrackersFetch<T> {
             last_change_tick,
             change_tick,
         };
-        if state.storage_type == StorageType::SparseSet {
+        if T::Storage::STORAGE_TYPE == StorageType::SparseSet {
             value.sparse_set = world
                 .storages()
                 .sparse_sets
@@ -857,7 +843,7 @@ impl<'w, T: Component> Fetch<'w> for ChangeTrackersFetch<T> {
         archetype: &Archetype,
         tables: &Tables,
     ) {
-        match state.storage_type {
+        match T::Storage::STORAGE_TYPE {
             StorageType::Table => {
                 self.entity_table_rows = archetype.entity_table_rows().as_ptr();
                 let column = tables[archetype.table_id()]
@@ -879,7 +865,7 @@ impl<'w, T: Component> Fetch<'w> for ChangeTrackersFetch<T> {
 
     #[inline]
     unsafe fn archetype_fetch(&mut self, archetype_index: usize) -> Self::Item {
-        match self.storage_type {
+        match T::Storage::STORAGE_TYPE {
             StorageType::Table => {
                 let table_row = *self.entity_table_rows.add(archetype_index);
                 ChangeTrackers {
diff --git a/crates/bevy_ecs/src/query/filter.rs b/crates/bevy_ecs/src/query/filter.rs
index 05f0befd45134..b3b27736f8266 100644
--- a/crates/bevy_ecs/src/query/filter.rs
+++ b/crates/bevy_ecs/src/query/filter.rs
@@ -1,7 +1,7 @@
 use crate::{
     archetype::{Archetype, ArchetypeComponentId},
     bundle::Bundle,
-    component::{Component, ComponentId, ComponentTicks, StorageType},
+    component::{Component, ComponentId, ComponentStorage, ComponentTicks, StorageType},
     entity::Entity,
     query::{Access, Fetch, FetchState, FilteredAccess, WorldQuery},
     storage::{ComponentSparseSet, Table, Tables},
@@ -77,14 +77,12 @@ impl<T: Component> WorldQuery for With<T> {
 
 /// The [`Fetch`] of [`With`].
 pub struct WithFetch<T> {
-    storage_type: StorageType,
     marker: PhantomData<T>,
 }
 
 /// The [`FetchState`] of [`With`].
 pub struct WithState<T> {
     component_id: ComponentId,
-    storage_type: StorageType,
     marker: PhantomData<T>,
 }
 
@@ -94,7 +92,6 @@ unsafe impl<T: Component> FetchState for WithState<T> {
         let component_info = world.components.get_or_insert_info::<T>();
         Self {
             component_id: component_info.id(),
-            storage_type: component_info.storage_type(),
             marker: PhantomData,
         }
     }
@@ -127,19 +124,18 @@ impl<'a, T: Component> Fetch<'a> for WithFetch<T> {
 
     unsafe fn init(
         _world: &World,
-        state: &Self::State,
+        _state: &Self::State,
         _last_change_tick: u32,
         _change_tick: u32,
     ) -> Self {
         Self {
-            storage_type: state.storage_type,
             marker: PhantomData,
         }
     }
 
     #[inline]
     fn is_dense(&self) -> bool {
-        self.storage_type == StorageType::Table
+        T::Storage::STORAGE_TYPE == StorageType::Table
     }
 
     #[inline]
@@ -198,14 +194,12 @@ impl<T: Component> WorldQuery for Without<T> {
 
 /// The [`Fetch`] of [`Without`].
 pub struct WithoutFetch<T> {
-    storage_type: StorageType,
     marker: PhantomData<T>,
 }
 
 /// The [`FetchState`] of [`Without`].
 pub struct WithoutState<T> {
     component_id: ComponentId,
-    storage_type: StorageType,
     marker: PhantomData<T>,
 }
 
@@ -215,7 +209,6 @@ unsafe impl<T: Component> FetchState for WithoutState<T> {
         let component_info = world.components.get_or_insert_info::<T>();
         Self {
             component_id: component_info.id(),
-            storage_type: component_info.storage_type(),
             marker: PhantomData,
         }
     }
@@ -248,19 +241,18 @@ impl<'a, T: Component> Fetch<'a> for WithoutFetch<T> {
 
     unsafe fn init(
         _world: &World,
-        state: &Self::State,
+        _state: &Self::State,
         _last_change_tick: u32,
         _change_tick: u32,
     ) -> Self {
         Self {
-            storage_type: state.storage_type,
             marker: PhantomData,
         }
     }
 
     #[inline]
     fn is_dense(&self) -> bool {
-        self.storage_type == StorageType::Table
+        T::Storage::STORAGE_TYPE == StorageType::Table
     }
 
     #[inline]
@@ -294,13 +286,11 @@ impl<T: Bundle> WorldQuery for WithBundle<T> {
 }
 
 pub struct WithBundleFetch<T: Bundle> {
-    is_dense: bool,
     marker: PhantomData<T>,
 }
 
 pub struct WithBundleState<T: Bundle> {
     component_ids: Vec<ComponentId>,
-    is_dense: bool,
     marker: PhantomData<T>,
 }
 
@@ -308,12 +298,8 @@ pub struct WithBundleState<T: Bundle> {
 unsafe impl<T: Bundle> FetchState for WithBundleState<T> {
     fn init(world: &mut World) -> Self {
         let bundle_info = world.bundles.init_info::<T>(&mut world.components);
-        let components = &world.components;
         Self {
             component_ids: bundle_info.component_ids.clone(),
-            is_dense: !bundle_info.component_ids.iter().any(|id| unsafe {
-                components.get_info_unchecked(*id).storage_type() != StorageType::Table
-            }),
             marker: PhantomData,
         }
     }
@@ -348,19 +334,18 @@ impl<'a, T: Bundle> Fetch<'a> for WithBundleFetch<T> {
 
     unsafe fn init(
         _world: &World,
-        state: &Self::State,
+        _state: &Self::State,
         _last_change_tick: u32,
         _change_tick: u32,
     ) -> Self {
         Self {
-            is_dense: state.is_dense,
             marker: PhantomData,
         }
     }
 
     #[inline]
     fn is_dense(&self) -> bool {
-        self.is_dense
+        T::is_dense()
     }
 
     #[inline]
@@ -633,7 +618,7 @@ macro_rules! impl_tick_filter {
                     last_change_tick,
                     change_tick,
                 };
-                if state.storage_type == StorageType::SparseSet {
+                if T::Storage::STORAGE_TYPE == StorageType::SparseSet {
                     value.sparse_set = world
                         .storages()
                         .sparse_sets
@@ -644,7 +629,7 @@ macro_rules! impl_tick_filter {
 
             #[inline]
             fn is_dense(&self) -> bool {
-                self.storage_type == StorageType::Table
+                T::Storage::STORAGE_TYPE == StorageType::Table
             }
 
             unsafe fn set_table(&mut self, state: &Self::State, table: &Table) {
diff --git a/crates/bevy_ecs/src/query/iter.rs b/crates/bevy_ecs/src/query/iter.rs
index 82ddf458cb40f..87641d7a7da75 100644
--- a/crates/bevy_ecs/src/query/iter.rs
+++ b/crates/bevy_ecs/src/query/iter.rs
@@ -24,7 +24,6 @@ where
     filter: F::Fetch,
     current_len: usize,
     current_index: usize,
-    is_dense: bool,
 }
 
 impl<'w, 's, Q: WorldQuery, F: WorldQuery> QueryIter<'w, 's, Q, F>
@@ -60,7 +59,6 @@ where
             query_state,
             tables: &world.storages().tables,
             archetypes: &world.archetypes,
-            is_dense: fetch.is_dense() && filter.is_dense(),
             fetch,
             filter,
             table_id_iter: query_state.matched_table_ids.iter(),
@@ -76,7 +74,7 @@ where
         // NOTE: this mimics the behavior of `QueryIter::next()`, except that it
         // never gets a `Self::Item`.
         unsafe {
-            if self.is_dense {
+            if self.fetch.is_dense() && self.filter.is_dense() {
                 loop {
                     if self.current_index == self.current_len {
                         let table_id = match self.table_id_iter.next() {
@@ -139,7 +137,7 @@ where
     #[inline(always)]
     fn next(&mut self) -> Option<Self::Item> {
         unsafe {
-            if self.is_dense {
+            if self.fetch.is_dense() && self.filter.is_dense() {
                 loop {
                     if self.current_index == self.current_len {
                         let table_id = self.table_id_iter.next()?;
@@ -411,7 +409,6 @@ struct QueryIterationCursor<'s, Q: WorldQuery, F: WorldQuery> {
     filter: F::Fetch,
     current_len: usize,
     current_index: usize,
-    is_dense: bool,
 }
 
 impl<'s, Q: WorldQuery, F: WorldQuery> Clone for QueryIterationCursor<'s, Q, F>
@@ -427,7 +424,6 @@ where
             filter: self.filter.clone(),
             current_len: self.current_len,
             current_index: self.current_index,
-            is_dense: self.is_dense,
         }
     }
 }
@@ -468,7 +464,6 @@ where
             change_tick,
         );
         QueryIterationCursor {
-            is_dense: fetch.is_dense() && filter.is_dense(),
             fetch,
             filter,
             table_id_iter: query_state.matched_table_ids.iter(),
@@ -482,7 +477,7 @@ where
     #[inline]
     unsafe fn peek_last<'w>(&mut self) -> Option<<Q::Fetch as Fetch<'w>>::Item> {
         if self.current_index > 0 {
-            if self.is_dense {
+            if self.fetch.is_dense() && self.filter.is_dense() {
                 Some(self.fetch.table_fetch(self.current_index - 1))
             } else {
                 Some(self.fetch.archetype_fetch(self.current_index - 1))
@@ -502,7 +497,7 @@ where
         archetypes: &'w Archetypes,
         query_state: &'s QueryState<Q, F>,
     ) -> Option<<Q::Fetch as Fetch<'w>>::Item> {
-        if self.is_dense {
+        if self.fetch.is_dense() && self.filter.is_dense() {
             loop {
                 if self.current_index == self.current_len {
                     let table_id = self.table_id_iter.next()?;
diff --git a/crates/bevy_ecs/src/system/commands.rs b/crates/bevy_ecs/src/system/commands.rs
index d62c0da5b47ab..a933840cec54a 100644
--- a/crates/bevy_ecs/src/system/commands.rs
+++ b/crates/bevy_ecs/src/system/commands.rs
@@ -455,7 +455,8 @@ mod tests {
     };
 
     #[derive(Component)]
-    struct DenseDropCk(DropCk);
+    #[storage(sparse)]
+    struct SparseDropCk(DropCk);
 
     #[derive(Component)]
     struct DropCk(Arc<AtomicUsize>);
@@ -506,14 +507,10 @@ mod tests {
     fn remove_components() {
         let mut world = World::default();
 
-        world
-            .register_component(ComponentDescriptor::new::<DropCk>(StorageType::SparseSet))
-            .unwrap();
-
         let mut command_queue = CommandQueue::default();
         let (dense_dropck, dense_is_dropped) = DropCk::new_pair();
-        let dense_dropck = DenseDropCk(dense_dropck);
         let (sparse_dropck, sparse_is_dropped) = DropCk::new_pair();
+        let sparse_dropck = SparseDropCk(sparse_dropck);
 
         let entity = Commands::new(&mut command_queue, &world)
             .spawn()
@@ -531,7 +528,7 @@ mod tests {
         Commands::new(&mut command_queue, &world)
             .entity(entity)
             .remove::<u32>()
-            .remove_bundle::<(u32, u64, DenseDropCk, DropCk)>();
+            .remove_bundle::<(u32, u64, SparseDropCk, DropCk)>();
 
         assert_eq!(dense_is_dropped.load(Ordering::Relaxed), 0);
         assert_eq!(sparse_is_dropped.load(Ordering::Relaxed), 0);
diff --git a/crates/bevy_render/src/draw.rs b/crates/bevy_render/src/draw.rs
index 1006ec4166a4d..2812139b3af11 100644
--- a/crates/bevy_render/src/draw.rs
+++ b/crates/bevy_render/src/draw.rs
@@ -76,6 +76,7 @@ impl Default for Visible {
 /// need to support multiple views (ex: set the `SpriteSettings::frustum_culling_enabled` resource).
 #[derive(Component, Debug, Default, Clone, Reflect)]
 #[reflect(Component)]
+#[storage(sparse)]
 pub struct OutsideFrustum;
 
 /// A component that indicates how to draw an entity.
diff --git a/crates/bevy_sprite/src/lib.rs b/crates/bevy_sprite/src/lib.rs
index eebb2bc25215b..6ed73ef261409 100644
--- a/crates/bevy_sprite/src/lib.rs
+++ b/crates/bevy_sprite/src/lib.rs
@@ -96,13 +96,6 @@ impl Plugin for SpritePlugin {
                 frustum_culling::atlas_frustum_culling_system.system(),
             );
         }
-        let world = app.world_mut();
-        world
-            .register_component(ComponentDescriptor::new::<OutsideFrustum>(
-                StorageType::SparseSet,
-            ))
-            .unwrap();
-
         let world_cell = world.cell();
         let mut render_graph = world_cell.get_resource_mut::<RenderGraph>().unwrap();
         let mut pipelines = world_cell

From 40711df67a5e6a7766a6c3c59bcaf8783f826b7c Mon Sep 17 00:00:00 2001
From: Frizi <frizi09@gmail.com>
Date: Wed, 9 Jun 2021 18:34:32 +0200
Subject: [PATCH 06/22] use associated const for is_dense

---
 crates/bevy_ecs/macros/src/component.rs |  5 ++-
 crates/bevy_ecs/macros/src/lib.rs       | 23 ++++++--------
 crates/bevy_ecs/src/bundle.rs           | 29 +++++++++++------
 crates/bevy_ecs/src/query/fetch.rs      | 34 ++++++--------------
 crates/bevy_ecs/src/query/filter.rs     | 41 ++++++++++++-------------
 crates/bevy_ecs/src/query/iter.rs       |  8 ++---
 crates/bevy_ecs/src/query/state.rs      |  9 ++----
 crates/bevy_ecs/src/system/commands.rs  |  2 +-
 crates/bevy_sprite/src/lib.rs           |  7 ++---
 9 files changed, 72 insertions(+), 86 deletions(-)

diff --git a/crates/bevy_ecs/macros/src/component.rs b/crates/bevy_ecs/macros/src/component.rs
index e69c31f43a333..ea34ebdacf3ae 100644
--- a/crates/bevy_ecs/macros/src/component.rs
+++ b/crates/bevy_ecs/macros/src/component.rs
@@ -40,7 +40,10 @@ fn parse_storage_attribute(attr: &Attribute) -> Result<StorageTy> {
     match ident.to_string().as_str() {
         "table" => Ok(StorageTy::Table),
         "sparse" => Ok(StorageTy::Sparse),
-        _ => Err(Error::new(ident.span(), "Invalid storage type, expected 'table' or 'sparse'.")),
+        _ => Err(Error::new(
+            ident.span(),
+            "Invalid storage type, expected 'table' or 'sparse'.",
+        )),
     }
 }
 
diff --git a/crates/bevy_ecs/macros/src/lib.rs b/crates/bevy_ecs/macros/src/lib.rs
index a2efa81d2aee3..6a87c9179bed8 100644
--- a/crates/bevy_ecs/macros/src/lib.rs
+++ b/crates/bevy_ecs/macros/src/lib.rs
@@ -115,8 +115,7 @@ pub fn derive_bundle(input: TokenStream) -> TokenStream {
     let mut field_type_infos = Vec::new();
     let mut field_get_components = Vec::new();
     let mut field_from_components = Vec::new();
-    let mut is_dense_const_exprs = Vec::new();
-    let mut is_dense_fn_exprs = Vec::new();
+    let mut is_dense_exprs = Vec::new();
     for ((field_type, is_bundle), field) in
         field_type.iter().zip(is_bundle.iter()).zip(field.iter())
     {
@@ -130,8 +129,8 @@ pub fn derive_bundle(input: TokenStream) -> TokenStream {
             field_from_components.push(quote! {
                 #field: <#field_type as #ecs_path::bundle::Bundle>::from_components(&mut func),
             });
-            is_dense_fn_exprs.push(quote! {
-                <#field_type as #ecs_path::bundle::Bundle>::is_dense()
+            is_dense_exprs.push(quote! {
+                <#field_type as #ecs_path::bundle::Bundle>::IS_DENSE
             });
         } else {
             field_type_infos.push(quote! {
@@ -144,9 +143,11 @@ pub fn derive_bundle(input: TokenStream) -> TokenStream {
             field_from_components.push(quote! {
                 #field: func().cast::<#field_type>().read(),
             });
-            is_dense_const_exprs.push(quote! {
-                <<#field_type as #ecs_path::component::Component>::Storage as #ecs_path::component::ComponentStorage>::STORAGE_TYPE
-                    == #ecs_path::component::StorageType::Table
+            is_dense_exprs.push(quote! {
+                match <<#field_type as #ecs_path::component::Component>::Storage as #ecs_path::component::ComponentStorage>::STORAGE_TYPE {
+                    #ecs_path::component::StorageType::Table => true,
+                    #ecs_path::component::StorageType::SparseSet => false,
+                }
             });
         }
     }
@@ -158,18 +159,14 @@ pub fn derive_bundle(input: TokenStream) -> TokenStream {
     TokenStream::from(quote! {
         /// SAFE: TypeInfo is returned in field-definition-order. [from_components] and [get_components] use field-definition-order
         unsafe impl #impl_generics #ecs_path::bundle::Bundle for #struct_name#ty_generics #where_clause {
+            const IS_DENSE: bool = true #(&& #is_dense_exprs)*;
+
             fn type_info() -> Vec<#ecs_path::component::TypeInfo> {
                 let mut type_info = Vec::with_capacity(#field_len);
                 #(#field_type_infos)*
                 type_info
             }
 
-            #[inline(always)]
-            fn is_dense() -> bool {
-                // insert const expressions in front to avoid evaluating non-const functions if possible
-                true #(&& (#is_dense_const_exprs))* #(&& #is_dense_fn_exprs)*
-            }
-
             #[allow(unused_variables, unused_mut, non_snake_case)]
             unsafe fn from_components(mut func: impl FnMut() -> *mut u8) -> Self {
                 Self {
diff --git a/crates/bevy_ecs/src/bundle.rs b/crates/bevy_ecs/src/bundle.rs
index 9b2791b42ea7e..d68533618ecf2 100644
--- a/crates/bevy_ecs/src/bundle.rs
+++ b/crates/bevy_ecs/src/bundle.rs
@@ -23,19 +23,26 @@ use std::{any::TypeId, collections::HashMap};
 ///
 /// You can nest bundles like so:
 /// ```
-/// # use bevy_ecs::bundle::Bundle;
+/// # use bevy_ecs::{component::Component, bundle::Bundle};
+///
+/// #[derive(Component)]
+/// struct X(i32);
+/// #[derive(Component)]
+/// struct Y(u64);
+/// #[derive(Component)]
+/// struct Z(String);
 ///
 /// #[derive(Bundle)]
 /// struct A {
-///     x: i32,
-///     y: u64,
+///     x: X,
+///     y: Y,
 /// }
 ///
 /// #[derive(Bundle)]
 /// struct B {
 ///     #[bundle]
 ///     a: A,
-///     z: String,
+///     z: Z,
 /// }
 /// ```
 ///
@@ -45,6 +52,8 @@ use std::{any::TypeId, collections::HashMap};
 /// [Bundle::from_components] must call `func` exactly once for each [TypeInfo] returned by
 /// [Bundle::type_info]
 pub unsafe trait Bundle: Send + Sync + 'static {
+    const IS_DENSE: bool;
+
     /// Gets this [Bundle]'s components type info, in the order of this bundle's Components
     fn type_info() -> Vec<TypeInfo>;
 
@@ -62,8 +71,6 @@ pub unsafe trait Bundle: Send + Sync + 'static {
     /// "mem::forget" the bundle fields, so callers are responsible for dropping the fields if
     /// that is desirable.
     fn get_components(self, func: impl FnMut(*mut u8));
-
-    fn is_dense() -> bool;
 }
 
 macro_rules! tuple_impl {
@@ -74,10 +81,12 @@ macro_rules! tuple_impl {
                 vec![$(TypeInfo::of::<$name>()),*]
             }
 
-            #[inline(always)]
-            fn is_dense() -> bool {
-                true $(&& $name::Storage::STORAGE_TYPE == StorageType::Table)*
-            }
+            const IS_DENSE: bool = true $(&&
+                match $name::Storage::STORAGE_TYPE {
+                    StorageType::Table => true,
+                    StorageType::SparseSet => false,
+                }
+            )*;
 
             #[allow(unused_variables, unused_mut)]
             unsafe fn from_components(mut func: impl FnMut() -> *mut u8) -> Self {
diff --git a/crates/bevy_ecs/src/query/fetch.rs b/crates/bevy_ecs/src/query/fetch.rs
index b4a197126c4be..1d1d5595a7566 100644
--- a/crates/bevy_ecs/src/query/fetch.rs
+++ b/crates/bevy_ecs/src/query/fetch.rs
@@ -67,7 +67,7 @@ pub trait Fetch<'w>: Sized {
     /// for "dense" queries. If this returns true, [`Fetch::set_table`] and [`Fetch::table_fetch`]
     /// will be called for iterators. If this returns false, [`Fetch::set_archetype`] and
     /// [`Fetch::archetype_fetch`] will be called for iterators.
-    fn is_dense(&self) -> bool;
+    const IS_DENSE: bool;
 
     /// Adjusts internal state to account for the next [`Archetype`]. This will always be called on
     /// archetypes that match this [`Fetch`].
@@ -177,10 +177,7 @@ impl<'w> Fetch<'w> for EntityFetch {
     type Item = Entity;
     type State = EntityState;
 
-    #[inline]
-    fn is_dense(&self) -> bool {
-        true
-    }
+    const IS_DENSE: bool = true;
 
     unsafe fn init(
         _world: &World,
@@ -296,13 +293,12 @@ impl<'w, T: Component> Fetch<'w> for ReadFetch<T> {
     type Item = &'w T;
     type State = ReadState<T>;
 
-    #[inline]
-    fn is_dense(&self) -> bool {
+    const IS_DENSE: bool = {
         match T::Storage::STORAGE_TYPE {
             StorageType::Table => true,
             StorageType::SparseSet => false,
         }
-    }
+    };
 
     unsafe fn init(
         world: &World,
@@ -454,13 +450,12 @@ impl<'w, T: Component> Fetch<'w> for WriteFetch<T> {
     type Item = Mut<'w, T>;
     type State = WriteState<T>;
 
-    #[inline]
-    fn is_dense(&self) -> bool {
+    const IS_DENSE: bool = {
         match T::Storage::STORAGE_TYPE {
             StorageType::Table => true,
             StorageType::SparseSet => false,
         }
-    }
+    };
 
     unsafe fn init(
         world: &World,
@@ -613,10 +608,7 @@ impl<'w, T: Fetch<'w>> Fetch<'w> for OptionFetch<T> {
     type Item = Option<T::Item>;
     type State = OptionState<T::State>;
 
-    #[inline]
-    fn is_dense(&self) -> bool {
-        self.fetch.is_dense()
-    }
+    const IS_DENSE: bool = T::IS_DENSE;
 
     unsafe fn init(
         world: &World,
@@ -803,13 +795,12 @@ impl<'w, T: Component> Fetch<'w> for ChangeTrackersFetch<T> {
     type Item = ChangeTrackers<T>;
     type State = ChangeTrackersState<T>;
 
-    #[inline]
-    fn is_dense(&self) -> bool {
+    const IS_DENSE: bool = {
         match T::Storage::STORAGE_TYPE {
             StorageType::Table => true,
             StorageType::SparseSet => false,
         }
-    }
+    };
 
     unsafe fn init(
         world: &World,
@@ -910,12 +901,7 @@ macro_rules! impl_tuple_fetch {
                 ($($name::init(_world, $name, _last_change_tick, _change_tick),)*)
             }
 
-
-            #[inline]
-            fn is_dense(&self) -> bool {
-                let ($($name,)*) = self;
-                true $(&& $name.is_dense())*
-            }
+            const IS_DENSE: bool = true $(&& $name::IS_DENSE)*;
 
             #[inline]
             unsafe fn set_archetype(&mut self, _state: &Self::State, _archetype: &Archetype, _tables: &Tables) {
diff --git a/crates/bevy_ecs/src/query/filter.rs b/crates/bevy_ecs/src/query/filter.rs
index b3b27736f8266..0fc067c656447 100644
--- a/crates/bevy_ecs/src/query/filter.rs
+++ b/crates/bevy_ecs/src/query/filter.rs
@@ -133,10 +133,12 @@ impl<'a, T: Component> Fetch<'a> for WithFetch<T> {
         }
     }
 
-    #[inline]
-    fn is_dense(&self) -> bool {
-        T::Storage::STORAGE_TYPE == StorageType::Table
-    }
+    const IS_DENSE: bool = {
+        match T::Storage::STORAGE_TYPE {
+            StorageType::Table => true,
+            StorageType::SparseSet => false,
+        }
+    };
 
     #[inline]
     unsafe fn set_table(&mut self, _state: &Self::State, _table: &Table) {}
@@ -250,10 +252,12 @@ impl<'a, T: Component> Fetch<'a> for WithoutFetch<T> {
         }
     }
 
-    #[inline]
-    fn is_dense(&self) -> bool {
-        T::Storage::STORAGE_TYPE == StorageType::Table
-    }
+    const IS_DENSE: bool = {
+        match T::Storage::STORAGE_TYPE {
+            StorageType::Table => true,
+            StorageType::SparseSet => false,
+        }
+    };
 
     #[inline]
     unsafe fn set_table(&mut self, _state: &Self::State, _table: &Table) {}
@@ -343,10 +347,7 @@ impl<'a, T: Bundle> Fetch<'a> for WithBundleFetch<T> {
         }
     }
 
-    #[inline]
-    fn is_dense(&self) -> bool {
-        T::is_dense()
-    }
+    const IS_DENSE: bool = T::IS_DENSE;
 
     #[inline]
     unsafe fn set_table(&mut self, _state: &Self::State, _table: &Table) {}
@@ -449,11 +450,7 @@ macro_rules! impl_query_filter_tuple {
                 },)*))
             }
 
-            #[inline]
-            fn is_dense(&self) -> bool {
-                let ($($filter,)*) = &self.0;
-                true $(&& $filter.fetch.is_dense())*
-            }
+            const IS_DENSE: bool = true $(&& $filter::IS_DENSE)*;
 
             #[inline]
             unsafe fn set_table(&mut self, state: &Self::State, table: &Table) {
@@ -627,10 +624,12 @@ macro_rules! impl_tick_filter {
                 value
             }
 
-            #[inline]
-            fn is_dense(&self) -> bool {
-                T::Storage::STORAGE_TYPE == StorageType::Table
-            }
+            const IS_DENSE: bool = {
+                match T::Storage::STORAGE_TYPE {
+                    StorageType::Table => true,
+                    StorageType::SparseSet => false,
+                }
+            };
 
             unsafe fn set_table(&mut self, state: &Self::State, table: &Table) {
                 self.table_ticks = table
diff --git a/crates/bevy_ecs/src/query/iter.rs b/crates/bevy_ecs/src/query/iter.rs
index 87641d7a7da75..2513d0d0db6bb 100644
--- a/crates/bevy_ecs/src/query/iter.rs
+++ b/crates/bevy_ecs/src/query/iter.rs
@@ -74,7 +74,7 @@ where
         // NOTE: this mimics the behavior of `QueryIter::next()`, except that it
         // never gets a `Self::Item`.
         unsafe {
-            if self.fetch.is_dense() && self.filter.is_dense() {
+            if Q::Fetch::IS_DENSE && F::Fetch::IS_DENSE {
                 loop {
                     if self.current_index == self.current_len {
                         let table_id = match self.table_id_iter.next() {
@@ -137,7 +137,7 @@ where
     #[inline(always)]
     fn next(&mut self) -> Option<Self::Item> {
         unsafe {
-            if self.fetch.is_dense() && self.filter.is_dense() {
+            if Q::Fetch::IS_DENSE && F::Fetch::IS_DENSE {
                 loop {
                     if self.current_index == self.current_len {
                         let table_id = self.table_id_iter.next()?;
@@ -477,7 +477,7 @@ where
     #[inline]
     unsafe fn peek_last<'w>(&mut self) -> Option<<Q::Fetch as Fetch<'w>>::Item> {
         if self.current_index > 0 {
-            if self.fetch.is_dense() && self.filter.is_dense() {
+            if Q::Fetch::IS_DENSE && F::Fetch::IS_DENSE {
                 Some(self.fetch.table_fetch(self.current_index - 1))
             } else {
                 Some(self.fetch.archetype_fetch(self.current_index - 1))
@@ -497,7 +497,7 @@ where
         archetypes: &'w Archetypes,
         query_state: &'s QueryState<Q, F>,
     ) -> Option<<Q::Fetch as Fetch<'w>>::Item> {
-        if self.fetch.is_dense() && self.filter.is_dense() {
+        if Q::Fetch::IS_DENSE && F::Fetch::IS_DENSE {
             loop {
                 if self.current_index == self.current_len {
                     let table_id = self.table_id_iter.next()?;
diff --git a/crates/bevy_ecs/src/query/state.rs b/crates/bevy_ecs/src/query/state.rs
index 05c009c6e82db..663a63647afbe 100644
--- a/crates/bevy_ecs/src/query/state.rs
+++ b/crates/bevy_ecs/src/query/state.rs
@@ -406,7 +406,7 @@ where
             <Q::Fetch as Fetch>::init(world, &self.fetch_state, last_change_tick, change_tick);
         let mut filter =
             <F::Fetch as Fetch>::init(world, &self.filter_state, last_change_tick, change_tick);
-        if fetch.is_dense() && filter.is_dense() {
+        if Q::Fetch::IS_DENSE && F::Fetch::IS_DENSE {
             let tables = &world.storages().tables;
             for table_id in self.matched_table_ids.iter() {
                 let table = &tables[*table_id];
@@ -457,12 +457,7 @@ where
         // NOTE: If you are changing query iteration code, remember to update the following places, where relevant:
         // QueryIter, QueryIterationCursor, QueryState::for_each_unchecked_manual, QueryState::par_for_each_unchecked_manual
         task_pool.scope(|scope| {
-            let fetch =
-                <Q::Fetch as Fetch>::init(world, &self.fetch_state, last_change_tick, change_tick);
-            let filter =
-                <F::Fetch as Fetch>::init(world, &self.filter_state, last_change_tick, change_tick);
-
-            if fetch.is_dense() && filter.is_dense() {
+            if Q::Fetch::IS_DENSE && F::Fetch::IS_DENSE {
                 let tables = &world.storages().tables;
                 for table_id in self.matched_table_ids.iter() {
                     let table = &tables[*table_id];
diff --git a/crates/bevy_ecs/src/system/commands.rs b/crates/bevy_ecs/src/system/commands.rs
index a933840cec54a..c98a4ba3c5ec8 100644
--- a/crates/bevy_ecs/src/system/commands.rs
+++ b/crates/bevy_ecs/src/system/commands.rs
@@ -445,7 +445,7 @@ impl<T: Resource> Command for RemoveResource<T> {
 mod tests {
     use crate::{
         self as bevy_ecs,
-        component::{Component, ComponentDescriptor, StorageType},
+        component::Component,
         system::{CommandQueue, Commands},
         world::World,
     };
diff --git a/crates/bevy_sprite/src/lib.rs b/crates/bevy_sprite/src/lib.rs
index 6ed73ef261409..4076cac02dc52 100644
--- a/crates/bevy_sprite/src/lib.rs
+++ b/crates/bevy_sprite/src/lib.rs
@@ -28,14 +28,10 @@ pub use texture_atlas_builder::*;
 
 use bevy_app::prelude::*;
 use bevy_asset::{AddAsset, Assets, Handle, HandleUntyped};
-use bevy_ecs::{
-    component::{ComponentDescriptor, StorageType},
-    system::IntoSystem,
-};
+use bevy_ecs::system::IntoSystem;
 use bevy_math::Vec2;
 use bevy_reflect::TypeUuid;
 use bevy_render::{
-    draw::OutsideFrustum,
     mesh::{shape, Mesh},
     pipeline::PipelineDescriptor,
     render_graph::RenderGraph,
@@ -96,6 +92,7 @@ impl Plugin for SpritePlugin {
                 frustum_culling::atlas_frustum_culling_system.system(),
             );
         }
+        let world = app.world_mut();
         let world_cell = world.cell();
         let mut render_graph = world_cell.get_resource_mut::<RenderGraph>().unwrap();
         let mut pipelines = world_cell

From c76b48e8dced81de06e8d5009a7097bc5e0d2b28 Mon Sep 17 00:00:00 2001
From: Frizi <frizi09@gmail.com>
Date: Fri, 11 Jun 2021 21:42:24 +0200
Subject: [PATCH 07/22] new component attribute syntax

---
 crates/bevy_ecs/macros/src/component.rs | 85 +++++++++++++++++++------
 crates/bevy_ecs/macros/src/lib.rs       |  2 +-
 crates/bevy_ecs/src/system/commands.rs  |  2 +-
 crates/bevy_macro_utils/src/attrs.rs    | 50 +++++++++++++++
 crates/bevy_macro_utils/src/lib.rs      |  6 ++
 crates/bevy_macro_utils/src/symbol.rs   | 35 ++++++++++
 crates/bevy_render/src/draw.rs          |  2 +-
 7 files changed, 159 insertions(+), 23 deletions(-)
 create mode 100644 crates/bevy_macro_utils/src/attrs.rs
 create mode 100644 crates/bevy_macro_utils/src/symbol.rs

diff --git a/crates/bevy_ecs/macros/src/component.rs b/crates/bevy_ecs/macros/src/component.rs
index ea34ebdacf3ae..446210d0667ea 100644
--- a/crates/bevy_ecs/macros/src/component.rs
+++ b/crates/bevy_ecs/macros/src/component.rs
@@ -1,19 +1,19 @@
+use bevy_macro_utils::{get_lit_str, Symbol};
 use proc_macro::TokenStream;
 use proc_macro2::{Span, TokenStream as TokenStream2};
-use quote::quote;
-use syn::{parse_macro_input, parse_quote, Attribute, DeriveInput, Error, Ident, Path, Result};
+use quote::{quote, ToTokens};
+use syn::{parse_macro_input, parse_quote, DeriveInput, Error, Ident, Path, Result};
 
 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();
 
-    let storage = ast
-        .attrs
-        .iter()
-        .find(|attr| attr.path.is_ident("storage"))
-        .map_or(Ok(StorageTy::Table), parse_storage_attribute)
-        .map(|ty| storage_path(bevy_ecs_path.clone(), ty))
-        .unwrap_or_else(|err| err.to_compile_error());
+    let attrs = match parse_component_attr(&ast) {
+        Ok(attrs) => attrs,
+        Err(e) => return e.into_compile_error().into(),
+    };
+
+    let storage = storage_path(bevy_ecs_path.clone(), attrs.storage);
 
     ast.generics
         .make_where_clause()
@@ -30,27 +30,72 @@ pub fn derive_component(input: TokenStream) -> TokenStream {
     })
 }
 
+pub const COMPONENT: Symbol = Symbol("component");
+pub const STORAGE: Symbol = Symbol("storage");
+
+struct Attrs {
+    storage: StorageTy,
+}
+
+#[derive(Clone, Copy)]
 enum StorageTy {
     Table,
-    Sparse,
+    SparseSet,
 }
 
-fn parse_storage_attribute(attr: &Attribute) -> Result<StorageTy> {
-    let ident = attr.parse_args::<Ident>()?;
-    match ident.to_string().as_str() {
-        "table" => Ok(StorageTy::Table),
-        "sparse" => Ok(StorageTy::Sparse),
-        _ => Err(Error::new(
-            ident.span(),
-            "Invalid storage type, expected 'table' or 'sparse'.",
-        )),
+fn parse_component_attr(ast: &DeriveInput) -> Result<Attrs> {
+    let meta_items = bevy_macro_utils::parse_attrs(ast, COMPONENT)?;
+
+    let mut attrs = Attrs {
+        storage: StorageTy::Table,
+    };
+
+    for meta in meta_items {
+        use syn::{
+            Meta::NameValue,
+            NestedMeta::{Lit, Meta},
+        };
+        match meta {
+            Meta(NameValue(m)) if m.path == STORAGE => {
+                attrs.storage = match get_lit_str(STORAGE, &m.lit)?.value().as_str() {
+                    "Table" => StorageTy::Table,
+                    "SparseSet" => StorageTy::SparseSet,
+                    s => {
+                        return Err(Error::new_spanned(
+                            m.lit,
+                            format!(
+                                "Invalid storage type `{}`, expected 'table' or 'sparse'.",
+                                s
+                            ),
+                        ))
+                    }
+                };
+            }
+            Meta(meta_item) => {
+                return Err(Error::new_spanned(
+                    meta_item.path(),
+                    format!(
+                        "unknown component attribute `{}`",
+                        meta_item.path().into_token_stream().to_string()
+                    ),
+                ));
+            }
+            Lit(lit) => {
+                return Err(Error::new_spanned(
+                    lit,
+                    "unexpected literal in component attribute",
+                ))
+            }
+        }
     }
+
+    Ok(attrs)
 }
 
 fn storage_path(bevy_ecs_path: Path, ty: StorageTy) -> TokenStream2 {
     let typename = match ty {
         StorageTy::Table => Ident::new("TableStorage", Span::call_site()),
-        StorageTy::Sparse => Ident::new("SparseStorage", Span::call_site()),
+        StorageTy::SparseSet => Ident::new("SparseStorage", Span::call_site()),
     };
 
     quote! { #bevy_ecs_path::component::#typename }
diff --git a/crates/bevy_ecs/macros/src/lib.rs b/crates/bevy_ecs/macros/src/lib.rs
index 6a87c9179bed8..519ccbfc26693 100644
--- a/crates/bevy_ecs/macros/src/lib.rs
+++ b/crates/bevy_ecs/macros/src/lib.rs
@@ -493,7 +493,7 @@ pub(crate) fn bevy_ecs_path() -> syn::Path {
     BevyManifest::default().get_path("bevy_ecs")
 }
 
-#[proc_macro_derive(Component, attributes(storage))]
+#[proc_macro_derive(Component, attributes(component))]
 pub fn derive_component(input: TokenStream) -> TokenStream {
     component::derive_component(input)
 }
diff --git a/crates/bevy_ecs/src/system/commands.rs b/crates/bevy_ecs/src/system/commands.rs
index c98a4ba3c5ec8..a7b7a0ba562cf 100644
--- a/crates/bevy_ecs/src/system/commands.rs
+++ b/crates/bevy_ecs/src/system/commands.rs
@@ -455,7 +455,7 @@ mod tests {
     };
 
     #[derive(Component)]
-    #[storage(sparse)]
+    #[component(storage = "SparseSet")]
     struct SparseDropCk(DropCk);
 
     #[derive(Component)]
diff --git a/crates/bevy_macro_utils/src/attrs.rs b/crates/bevy_macro_utils/src/attrs.rs
new file mode 100644
index 0000000000000..a2f2746ca4fd9
--- /dev/null
+++ b/crates/bevy_macro_utils/src/attrs.rs
@@ -0,0 +1,50 @@
+use syn::DeriveInput;
+
+use crate::Symbol;
+
+pub fn get_attr_meta_items(
+    attr: &syn::Attribute,
+    attr_name: &'static str,
+) -> syn::Result<Vec<syn::NestedMeta>> {
+    if !attr.path.is_ident(attr_name) {
+        return Ok(Vec::new());
+    }
+
+    match attr.parse_meta()? {
+        syn::Meta::List(meta) => Ok(meta.nested.into_iter().collect()),
+        other => Err(syn::Error::new_spanned(
+            other,
+            format!("expected #[{}(...)]", attr_name),
+        )),
+    }
+}
+
+pub fn parse_attrs(ast: &DeriveInput, attr_name: Symbol) -> syn::Result<Vec<syn::NestedMeta>> {
+    let mut list = Vec::new();
+    for attr in ast.attrs.iter().filter(|a| a.path == attr_name) {
+        match attr.parse_meta()? {
+            syn::Meta::List(meta) => list.extend(meta.nested.into_iter()),
+            other => {
+                return Err(syn::Error::new_spanned(
+                    other,
+                    format!("expected #[{}(...)]", attr_name),
+                ))
+            }
+        }
+    }
+    Ok(list)
+}
+
+pub fn get_lit_str<'a>(attr_name: Symbol, lit: &'a syn::Lit) -> syn::Result<&'a syn::LitStr> {
+    if let syn::Lit::Str(lit) = lit {
+        Ok(lit)
+    } else {
+        Err(syn::Error::new_spanned(
+            lit,
+            format!(
+                "expected {} attribute to be a string: `{} = \"...\"`",
+                attr_name, attr_name
+            ),
+        ))
+    }
+}
diff --git a/crates/bevy_macro_utils/src/lib.rs b/crates/bevy_macro_utils/src/lib.rs
index 2933d9d8000d9..98e72e6a89e26 100644
--- a/crates/bevy_macro_utils/src/lib.rs
+++ b/crates/bevy_macro_utils/src/lib.rs
@@ -1,5 +1,11 @@
 extern crate proc_macro;
 
+mod attrs;
+mod symbol;
+
+pub use attrs::*;
+pub use symbol::*;
+
 use cargo_manifest::{DepsSet, Manifest};
 use proc_macro::TokenStream;
 use std::{env, path::PathBuf};
diff --git a/crates/bevy_macro_utils/src/symbol.rs b/crates/bevy_macro_utils/src/symbol.rs
new file mode 100644
index 0000000000000..dc639f4d83133
--- /dev/null
+++ b/crates/bevy_macro_utils/src/symbol.rs
@@ -0,0 +1,35 @@
+use std::fmt::{self, Display};
+use syn::{Ident, Path};
+
+#[derive(Copy, Clone)]
+pub struct Symbol(pub &'static str);
+
+impl PartialEq<Symbol> for Ident {
+    fn eq(&self, word: &Symbol) -> bool {
+        self == word.0
+    }
+}
+
+impl<'a> PartialEq<Symbol> for &'a Ident {
+    fn eq(&self, word: &Symbol) -> bool {
+        *self == word.0
+    }
+}
+
+impl PartialEq<Symbol> for Path {
+    fn eq(&self, word: &Symbol) -> bool {
+        self.is_ident(word.0)
+    }
+}
+
+impl<'a> PartialEq<Symbol> for &'a Path {
+    fn eq(&self, word: &Symbol) -> bool {
+        self.is_ident(word.0)
+    }
+}
+
+impl Display for Symbol {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        formatter.write_str(self.0)
+    }
+}
diff --git a/crates/bevy_render/src/draw.rs b/crates/bevy_render/src/draw.rs
index 2812139b3af11..7a3ba66f36e72 100644
--- a/crates/bevy_render/src/draw.rs
+++ b/crates/bevy_render/src/draw.rs
@@ -76,7 +76,7 @@ impl Default for Visible {
 /// need to support multiple views (ex: set the `SpriteSettings::frustum_culling_enabled` resource).
 #[derive(Component, Debug, Default, Clone, Reflect)]
 #[reflect(Component)]
-#[storage(sparse)]
+#[component(storage = "SparseSet")]
 pub struct OutsideFrustum;
 
 /// A component that indicates how to draw an entity.

From 335283534145433b2314f88a4dbc9dab146a6c0c Mon Sep 17 00:00:00 2001
From: = <=>
Date: Tue, 31 Aug 2021 15:35:10 +0300
Subject: [PATCH 08/22] some final fixes

---
 crates/bevy_app/src/app.rs                    | 10 +++--
 crates/bevy_ecs/examples/change_detection.rs  |  2 +-
 crates/bevy_ecs/examples/component_storage.rs | 39 -------------------
 3 files changed, 7 insertions(+), 44 deletions(-)
 delete mode 100644 crates/bevy_ecs/examples/component_storage.rs

diff --git a/crates/bevy_app/src/app.rs b/crates/bevy_app/src/app.rs
index 4b9a71812f083..bb89c1f154dc9 100644
--- a/crates/bevy_app/src/app.rs
+++ b/crates/bevy_app/src/app.rs
@@ -3,8 +3,10 @@ use bevy_ecs::{
     component::{Component, ComponentDescriptor},
     prelude::{FromWorld, IntoExclusiveSystem},
     schedule::{
-        IntoSystemDescriptor, RunOnce, Schedule, Stage, StageLabel, State, SystemSet, SystemStage,
+        IntoSystemDescriptor, RunOnce, Schedule, Stage, StageLabel, State, StateData, SystemSet,
+        SystemStage,
     },
+    system::Resource,
     world::World,
 };
 use bevy_utils::tracing::debug;
@@ -304,7 +306,7 @@ impl App {
     /// 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: StateData,
     {
         self.insert_resource(State::new(initial))
             .add_system_set_to_stage(stage, State::<T>::get_driver())
@@ -332,7 +334,7 @@ impl App {
     /// 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)
@@ -358,7 +360,7 @@ impl App {
     /// ```
     pub fn insert_resource<T>(&mut self, resource: T) -> &mut Self
     where
-        T: Component,
+        T: Resource,
     {
         self.world.insert_resource(resource);
         self
diff --git a/crates/bevy_ecs/examples/change_detection.rs b/crates/bevy_ecs/examples/change_detection.rs
index ec80dcb9393aa..1a3e135b654e2 100644
--- a/crates/bevy_ecs/examples/change_detection.rs
+++ b/crates/bevy_ecs/examples/change_detection.rs
@@ -46,7 +46,7 @@ struct EntityCounter {
 }
 
 // This struct represents a Component and holds the age in frames of the entity it gets assigned to
-#[derive(Default, Debug)]
+#[derive(Component, Default, Debug)]
 struct Age {
     frames: i32,
 }
diff --git a/crates/bevy_ecs/examples/component_storage.rs b/crates/bevy_ecs/examples/component_storage.rs
deleted file mode 100644
index 018f7afd4750c..0000000000000
--- a/crates/bevy_ecs/examples/component_storage.rs
+++ /dev/null
@@ -1,39 +0,0 @@
-use bevy_ecs::{
-    component::{ComponentDescriptor, StorageType},
-    prelude::*,
-};
-
-// This example shows how to configure the storage of Components.
-// A system demonstrates that querying for components is independent of their storage type.
-fn main() {
-    let mut world = World::new();
-
-    // Store components of type `i32` in a Sparse set
-    world
-        .register_component(ComponentDescriptor::new::<i32>(StorageType::SparseSet))
-        .expect("The component of type i32 is already in use");
-
-    // Components of type i32 will have the above configured Sparse set storage,
-    // while f64 components will have the default table storage
-    world.spawn().insert(1).insert(0.1);
-    world.spawn().insert(2);
-    world.spawn().insert(0.2);
-
-    // Setup a schedule and stage to add a system querying for the just spawned entities
-    let mut schedule = Schedule::default();
-    let mut update = SystemStage::parallel();
-    update.add_system(query_entities);
-    schedule.add_stage("update", update);
-
-    schedule.run(&mut world);
-}
-
-// The storage type does not matter for how to query in systems
-fn query_entities(entities_with_i32: Query<&i32>, entities_with_f64: Query<&f64>) {
-    for value in entities_with_i32.iter() {
-        println!("Got entity with i32: {}", value);
-    }
-    for value in entities_with_f64.iter() {
-        println!("Got entity with f64: {}", value);
-    }
-}

From 822ff0db88a7e44722b60f880f1a302294aa6ac8 Mon Sep 17 00:00:00 2001
From: = <=>
Date: Tue, 31 Aug 2021 15:40:13 +0300
Subject: [PATCH 09/22] more "final" fixes

---
 crates/bevy_sprite/src/lib.rs | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/crates/bevy_sprite/src/lib.rs b/crates/bevy_sprite/src/lib.rs
index 15808a82b91f4..04c43db1ac5d3 100644
--- a/crates/bevy_sprite/src/lib.rs
+++ b/crates/bevy_sprite/src/lib.rs
@@ -28,8 +28,6 @@ pub use texture_atlas_builder::*;
 
 use bevy_app::prelude::*;
 use bevy_asset::{AddAsset, Assets, Handle, HandleUntyped};
-use bevy_ecs::component::{ComponentDescriptor, StorageType};
-use bevy_ecs::system::IntoSystem;
 use bevy_math::Vec2;
 use bevy_reflect::TypeUuid;
 use bevy_render::{
@@ -90,7 +88,7 @@ impl Plugin for SpritePlugin {
                 frustum_culling::atlas_frustum_culling_system,
             );
         }
-        let world = app.world_mut();
+        let world = &mut app.world;
         let world_cell = world.cell();
         let mut render_graph = world_cell.get_resource_mut::<RenderGraph>().unwrap();
         let mut pipelines = world_cell

From d4ac8fde6c2759293275cefd0ccc5ee01490da53 Mon Sep 17 00:00:00 2001
From: = <=>
Date: Tue, 31 Aug 2021 19:19:06 +0300
Subject: [PATCH 10/22] all the fixes

---
 crates/bevy_app/src/app.rs                    |   6 +-
 crates/bevy_ecs/Cargo.toml                    |   4 -
 crates/bevy_ecs/src/component.rs              |  43 +-
 crates/bevy_ecs/src/lib.rs                    | 748 ++++++++++--------
 .../src/schedule/executor_parallel.rs         |  17 +-
 crates/bevy_ecs/src/schedule/stage.rs         |  15 +-
 crates/bevy_ecs/src/storage/table.rs          |   6 +-
 crates/bevy_ecs/src/system/commands/mod.rs    |  31 +-
 .../bevy_ecs/src/system/exclusive_system.rs   |  17 +-
 crates/bevy_ecs/src/system/mod.rs             |  15 +-
 crates/bevy_ecs/src/world/mod.rs              |  34 +-
 crates/bevy_macro_utils/src/attrs.rs          |   2 +-
 12 files changed, 507 insertions(+), 431 deletions(-)

diff --git a/crates/bevy_app/src/app.rs b/crates/bevy_app/src/app.rs
index bb89c1f154dc9..11efa7283b112 100644
--- a/crates/bevy_app/src/app.rs
+++ b/crates/bevy_app/src/app.rs
@@ -1,6 +1,6 @@
 use crate::{CoreStage, Events, Plugin, PluginGroup, PluginGroupBuilder, StartupStage};
 use bevy_ecs::{
-    component::{Component, ComponentDescriptor},
+    component::ComponentDescriptor,
     prelude::{FromWorld, IntoExclusiveSystem},
     schedule::{
         IntoSystemDescriptor, RunOnce, Schedule, Stage, StageLabel, State, StateData, SystemSet,
@@ -10,7 +10,7 @@ use bevy_ecs::{
     world::World,
 };
 use bevy_utils::tracing::debug;
-use std::{fmt::Debug, hash::Hash};
+use std::fmt::Debug;
 
 #[cfg(feature = "trace")]
 use bevy_utils::tracing::info_span;
@@ -294,7 +294,7 @@ impl App {
     /// 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: StateData,
     {
         self.add_state_to_stage(CoreStage::Update, initial)
     }
diff --git a/crates/bevy_ecs/Cargo.toml b/crates/bevy_ecs/Cargo.toml
index 00010a15252e0..1a359b6bd3b49 100644
--- a/crates/bevy_ecs/Cargo.toml
+++ b/crates/bevy_ecs/Cargo.toml
@@ -34,10 +34,6 @@ parking_lot = "0.11"
 name = "events"
 path = "examples/events.rs"
 
-[[example]]
-name = "component_storage"
-path = "examples/component_storage.rs"
-
 [[example]]
 name = "resources"
 path = "examples/resources.rs"
diff --git a/crates/bevy_ecs/src/component.rs b/crates/bevy_ecs/src/component.rs
index 0b743549614b0..388cd4690484e 100644
--- a/crates/bevy_ecs/src/component.rs
+++ b/crates/bevy_ecs/src/component.rs
@@ -60,53 +60,16 @@ where
     type Storage = TableStorage;
 }
 
-// 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, TableStorage};
-    impl Component for &'static str {
-        type Storage = TableStorage;
-    }
-    impl Component for usize {
-        type Storage = TableStorage;
-    }
-    impl Component for i32 {
-        type Storage = TableStorage;
-    }
-    impl Component for u32 {
-        type Storage = TableStorage;
-    }
-    impl Component for u64 {
-        type Storage = TableStorage;
-    }
-    impl Component for f32 {
-        type Storage = TableStorage;
-    }
-    impl Component for f64 {
-        type Storage = TableStorage;
-    }
-    impl Component for u8 {
-        type Storage = TableStorage;
-    }
-    impl Component for bool {
-        type Storage = TableStorage;
-    }
-}
-
 /// The storage used for a specific component type.
 ///
 /// # Examples
-/// The [`StorageType`] for a component is normally configured via `World::register_component`.
+/// The [`StorageType`] for a component is configured via the derive attribute
 ///
 /// ```
 /// # use bevy_ecs::{prelude::*, component::*};
-///
+/// #[derive(Component)]
+/// #[component(storage = "SparseSet")]
 /// struct A;
-///
-/// let mut world = World::default();
-/// world.register_component(ComponentDescriptor::new::<A>(StorageType::SparseSet));
 /// ```
 #[derive(Debug, Copy, Clone, Eq, PartialEq)]
 pub enum StorageType {
diff --git a/crates/bevy_ecs/src/lib.rs b/crates/bevy_ecs/src/lib.rs
index a2c6adec5ede4..f303315ea6d61 100644
--- a/crates/bevy_ecs/src/lib.rs
+++ b/crates/bevy_ecs/src/lib.rs
@@ -36,14 +36,13 @@ pub mod prelude {
         world::{FromWorld, Mut, World},
     };
 }
-// TODO: adjust tests to be compatible with type-based storage
-/*
+
 #[cfg(test)]
 mod tests {
     use crate as bevy_ecs;
     use crate::{
         bundle::Bundle,
-        component::{Component, ComponentDescriptor, ComponentId, StorageType},
+        component::{Component, ComponentId},
         entity::Entity,
         query::{
             Added, ChangeTrackers, Changed, FilterFetch, FilteredAccess, With, Without, WorldQuery,
@@ -60,11 +59,11 @@ mod tests {
         },
     };
 
-    #[derive(Component, Debug, PartialEq, Eq)]
+    #[derive(Component, Debug, PartialEq, Eq, Clone, Copy)]
     struct A(usize);
-    #[derive(Debug, PartialEq, Eq)]
+    #[derive(Component, Debug, PartialEq, Eq, Clone, Copy)]
     struct B(usize);
-    #[derive(Debug, PartialEq, Eq)]
+    #[derive(Component, Debug, PartialEq, Eq, Clone, Copy)]
     struct C;
 
     #[derive(Component, Clone, Debug)]
@@ -82,26 +81,37 @@ mod tests {
         }
     }
 
+    #[derive(Component, Copy, Clone, PartialEq, Eq, Debug)]
+    #[component(storage = "Table")]
+    struct TableStored(&'static str);
+    #[derive(Component, Copy, Clone, PartialEq, Eq, Debug)]
+    #[component(storage = "SparseSet")]
+    struct SparseStored(u32);
+
     #[test]
     fn random_access() {
         let mut world = World::new();
-        world
-            .register_component(ComponentDescriptor::new::<i32>(StorageType::SparseSet))
-            .unwrap();
-        let e = world.spawn().insert_bundle(("abc", 123)).id();
-        let f = world.spawn().insert_bundle(("def", 456, true)).id();
-        assert_eq!(*world.get::<&str>(e).unwrap(), "abc");
-        assert_eq!(*world.get::<i32>(e).unwrap(), 123);
-        assert_eq!(*world.get::<&str>(f).unwrap(), "def");
-        assert_eq!(*world.get::<i32>(f).unwrap(), 456);
+
+        let e = world
+            .spawn()
+            .insert_bundle((TableStored("abc"), SparseStored(123)))
+            .id();
+        let f = world
+            .spawn()
+            .insert_bundle((TableStored("def"), SparseStored(456), A(1)))
+            .id();
+        assert_eq!(world.get::<TableStored>(e).unwrap().0, "abc");
+        assert_eq!(world.get::<SparseStored>(e).unwrap().0, 123);
+        assert_eq!(world.get::<TableStored>(f).unwrap().0, "def");
+        assert_eq!(world.get::<SparseStored>(f).unwrap().0, 456);
 
         // test archetype get_mut()
-        *world.get_mut::<&'static str>(e).unwrap() = "xyz";
-        assert_eq!(*world.get::<&'static str>(e).unwrap(), "xyz");
+        world.get_mut::<TableStored>(e).unwrap().0 = "xyz";
+        assert_eq!(world.get::<TableStored>(e).unwrap().0, "xyz");
 
         // test sparse set get_mut()
-        *world.get_mut::<i32>(f).unwrap() = 42;
-        assert_eq!(*world.get::<i32>(f).unwrap(), 42);
+        world.get_mut::<SparseStored>(f).unwrap().0 = 42;
+        assert_eq!(world.get::<SparseStored>(f).unwrap().0, 42);
     }
 
     #[test]
@@ -110,79 +120,93 @@ mod tests {
 
         #[derive(Bundle, PartialEq, Debug)]
         struct Foo {
-            x: &'static str,
-            y: i32,
+            x: TableStored,
+            y: SparseStored,
         }
 
-        world
-            .register_component(ComponentDescriptor::new::<i32>(StorageType::SparseSet))
-            .unwrap();
-
         assert_eq!(
             <Foo as Bundle>::component_ids(world.components_mut()),
             vec![
-                world.components_mut().get_or_insert_id::<&'static str>(),
-                world.components_mut().get_or_insert_id::<i32>(),
+                world.components_mut().get_or_insert_id::<TableStored>(),
+                world.components_mut().get_or_insert_id::<SparseStored>(),
             ]
         );
 
-        let e1 = world.spawn().insert_bundle(Foo { x: "abc", y: 123 }).id();
-        let e2 = world.spawn().insert_bundle(("def", 456, true)).id();
-        assert_eq!(*world.get::<&str>(e1).unwrap(), "abc");
-        assert_eq!(*world.get::<i32>(e1).unwrap(), 123);
-        assert_eq!(*world.get::<&str>(e2).unwrap(), "def");
-        assert_eq!(*world.get::<i32>(e2).unwrap(), 456);
+        let e1 = world
+            .spawn()
+            .insert_bundle(Foo {
+                x: TableStored("abc"),
+                y: SparseStored(123),
+            })
+            .id();
+        let e2 = world
+            .spawn()
+            .insert_bundle((TableStored("def"), SparseStored(456), A(1)))
+            .id();
+        assert_eq!(world.get::<TableStored>(e1).unwrap().0, "abc");
+        assert_eq!(world.get::<SparseStored>(e1).unwrap().0, 123);
+        assert_eq!(world.get::<TableStored>(e2).unwrap().0, "def");
+        assert_eq!(world.get::<SparseStored>(e2).unwrap().0, 456);
 
         // test archetype get_mut()
-        *world.get_mut::<&'static str>(e1).unwrap() = "xyz";
-        assert_eq!(*world.get::<&'static str>(e1).unwrap(), "xyz");
+        world.get_mut::<TableStored>(e1).unwrap().0 = "xyz";
+        assert_eq!(world.get::<TableStored>(e1).unwrap().0, "xyz");
 
         // test sparse set get_mut()
-        *world.get_mut::<i32>(e2).unwrap() = 42;
-        assert_eq!(*world.get::<i32>(e2).unwrap(), 42);
+        world.get_mut::<SparseStored>(e2).unwrap().0 = 42;
+        assert_eq!(world.get::<SparseStored>(e2).unwrap().0, 42);
 
         assert_eq!(
             world.entity_mut(e1).remove_bundle::<Foo>().unwrap(),
-            Foo { x: "xyz", y: 123 }
+            Foo {
+                x: TableStored("xyz"),
+                y: SparseStored(123),
+            }
         );
 
         #[derive(Bundle, PartialEq, Debug)]
         struct Nested {
-            a: usize,
+            a: A,
             #[bundle]
             foo: Foo,
-            b: u8,
+            b: B,
         }
 
         assert_eq!(
             <Nested as Bundle>::component_ids(world.components_mut()),
             vec![
-                world.components_mut().get_or_insert_id::<usize>(),
-                world.components_mut().get_or_insert_id::<&'static str>(),
-                world.components_mut().get_or_insert_id::<i32>(),
-                world.components_mut().get_or_insert_id::<u8>(),
+                world.components_mut().get_or_insert_id::<A>(),
+                world.components_mut().get_or_insert_id::<TableStored>(),
+                world.components_mut().get_or_insert_id::<SparseStored>(),
+                world.components_mut().get_or_insert_id::<B>(),
             ]
         );
 
         let e3 = world
             .spawn()
             .insert_bundle(Nested {
-                a: 1,
-                foo: Foo { x: "ghi", y: 789 },
-                b: 2,
+                a: A(1),
+                foo: Foo {
+                    x: TableStored("ghi"),
+                    y: SparseStored(789),
+                },
+                b: B(2),
             })
             .id();
 
-        assert_eq!(*world.get::<&str>(e3).unwrap(), "ghi");
-        assert_eq!(*world.get::<i32>(e3).unwrap(), 789);
-        assert_eq!(*world.get::<usize>(e3).unwrap(), 1);
-        assert_eq!(*world.get::<u8>(e3).unwrap(), 2);
+        assert_eq!(world.get::<TableStored>(e3).unwrap().0, "ghi");
+        assert_eq!(world.get::<SparseStored>(e3).unwrap().0, 789);
+        assert_eq!(world.get::<A>(e3).unwrap().0, 1);
+        assert_eq!(world.get::<B>(e3).unwrap().0, 2);
         assert_eq!(
             world.entity_mut(e3).remove_bundle::<Nested>().unwrap(),
             Nested {
-                a: 1,
-                foo: Foo { x: "ghi", y: 789 },
-                b: 2,
+                a: A(1),
+                foo: Foo {
+                    x: TableStored("ghi"),
+                    y: SparseStored(789),
+                },
+                b: B(2),
             }
         );
     }
@@ -190,113 +214,167 @@ mod tests {
     #[test]
     fn despawn_table_storage() {
         let mut world = World::new();
-        let e = world.spawn().insert_bundle(("abc", 123)).id();
-        let f = world.spawn().insert_bundle(("def", 456)).id();
+        let e = world
+            .spawn()
+            .insert_bundle((TableStored("abc"), A(123)))
+            .id();
+        let f = world
+            .spawn()
+            .insert_bundle((TableStored("def"), A(456)))
+            .id();
         assert_eq!(world.entities.len(), 2);
         assert!(world.despawn(e));
         assert_eq!(world.entities.len(), 1);
-        assert!(world.get::<&str>(e).is_none());
-        assert!(world.get::<i32>(e).is_none());
-        assert_eq!(*world.get::<&str>(f).unwrap(), "def");
-        assert_eq!(*world.get::<i32>(f).unwrap(), 456);
+        assert!(world.get::<TableStored>(e).is_none());
+        assert!(world.get::<A>(e).is_none());
+        assert_eq!(world.get::<TableStored>(f).unwrap().0, "def");
+        assert_eq!(world.get::<A>(f).unwrap().0, 456);
     }
 
     #[test]
     fn despawn_mixed_storage() {
         let mut world = World::new();
-        world
-            .register_component(ComponentDescriptor::new::<i32>(StorageType::SparseSet))
-            .unwrap();
-        let e = world.spawn().insert_bundle(("abc", 123)).id();
-        let f = world.spawn().insert_bundle(("def", 456)).id();
+
+        let e = world
+            .spawn()
+            .insert_bundle((TableStored("abc"), SparseStored(123)))
+            .id();
+        let f = world
+            .spawn()
+            .insert_bundle((TableStored("def"), SparseStored(456)))
+            .id();
         assert_eq!(world.entities.len(), 2);
         assert!(world.despawn(e));
         assert_eq!(world.entities.len(), 1);
-        assert!(world.get::<&str>(e).is_none());
-        assert!(world.get::<i32>(e).is_none());
-        assert_eq!(*world.get::<&str>(f).unwrap(), "def");
-        assert_eq!(*world.get::<i32>(f).unwrap(), 456);
+        assert!(world.get::<TableStored>(e).is_none());
+        assert!(world.get::<SparseStored>(e).is_none());
+        assert_eq!(world.get::<TableStored>(f).unwrap().0, "def");
+        assert_eq!(world.get::<SparseStored>(f).unwrap().0, 456);
     }
 
     #[test]
     fn query_all() {
         let mut world = World::new();
-        let e = world.spawn().insert_bundle(("abc", 123)).id();
-        let f = world.spawn().insert_bundle(("def", 456)).id();
+        let e = world
+            .spawn()
+            .insert_bundle((TableStored("abc"), A(123)))
+            .id();
+        let f = world
+            .spawn()
+            .insert_bundle((TableStored("def"), A(456)))
+            .id();
 
         let ents = world
-            .query::<(Entity, &i32, &&str)>()
+            .query::<(Entity, &A, &TableStored)>()
             .iter(&world)
             .map(|(e, &i, &s)| (e, i, s))
             .collect::<Vec<_>>();
-        assert_eq!(ents, &[(e, 123, "abc"), (f, 456, "def")]);
+        assert_eq!(
+            ents,
+            &[
+                (e, A(123), TableStored("abc")),
+                (f, A(456), TableStored("def"))
+            ]
+        );
     }
 
     #[test]
     fn query_all_for_each() {
         let mut world = World::new();
-        let e = world.spawn().insert_bundle(("abc", 123)).id();
-        let f = world.spawn().insert_bundle(("def", 456)).id();
+        let e = world
+            .spawn()
+            .insert_bundle((TableStored("abc"), A(123)))
+            .id();
+        let f = world
+            .spawn()
+            .insert_bundle((TableStored("def"), A(456)))
+            .id();
 
         let mut results = Vec::new();
         world
-            .query::<(Entity, &i32, &&str)>()
+            .query::<(Entity, &A, &TableStored)>()
             .for_each(&world, |(e, &i, &s)| results.push((e, i, s)));
-        assert_eq!(results, &[(e, 123, "abc"), (f, 456, "def")]);
+        assert_eq!(
+            results,
+            &[
+                (e, A(123), TableStored("abc")),
+                (f, A(456), TableStored("def"))
+            ]
+        );
     }
 
     #[test]
     fn query_single_component() {
         let mut world = World::new();
-        let e = world.spawn().insert_bundle(("abc", 123)).id();
-        let f = world.spawn().insert_bundle(("def", 456, true)).id();
+        let e = world
+            .spawn()
+            .insert_bundle((TableStored("abc"), A(123)))
+            .id();
+        let f = world
+            .spawn()
+            .insert_bundle((TableStored("def"), A(456), B(1)))
+            .id();
         let ents = world
-            .query::<(Entity, &i32)>()
+            .query::<(Entity, &A)>()
             .iter(&world)
             .map(|(e, &i)| (e, i))
             .collect::<Vec<_>>();
-        assert_eq!(ents, &[(e, 123), (f, 456)]);
+        assert_eq!(ents, &[(e, A(123)), (f, A(456))]);
     }
 
     #[test]
     fn stateful_query_handles_new_archetype() {
         let mut world = World::new();
-        let e = world.spawn().insert_bundle(("abc", 123)).id();
-        let mut query = world.query::<(Entity, &i32)>();
+        let e = world
+            .spawn()
+            .insert_bundle((TableStored("abc"), A(123)))
+            .id();
+        let mut query = world.query::<(Entity, &A)>();
 
         let ents = query.iter(&world).map(|(e, &i)| (e, i)).collect::<Vec<_>>();
-        assert_eq!(ents, &[(e, 123)]);
+        assert_eq!(ents, &[(e, A(123))]);
 
-        let f = world.spawn().insert_bundle(("def", 456, true)).id();
+        let f = world
+            .spawn()
+            .insert_bundle((TableStored("def"), A(456), B(1)))
+            .id();
         let ents = query.iter(&world).map(|(e, &i)| (e, i)).collect::<Vec<_>>();
-        assert_eq!(ents, &[(e, 123), (f, 456)]);
+        assert_eq!(ents, &[(e, A(123)), (f, A(456))]);
     }
 
     #[test]
     fn query_single_component_for_each() {
         let mut world = World::new();
-        let e = world.spawn().insert_bundle(("abc", 123)).id();
-        let f = world.spawn().insert_bundle(("def", 456, true)).id();
+        let e = world
+            .spawn()
+            .insert_bundle((TableStored("abc"), A(123)))
+            .id();
+        let f = world
+            .spawn()
+            .insert_bundle((TableStored("def"), A(456), B(1)))
+            .id();
         let mut results = Vec::new();
         world
-            .query::<(Entity, &i32)>()
+            .query::<(Entity, &A)>()
             .for_each(&world, |(e, &i)| results.push((e, i)));
-        assert_eq!(results, &[(e, 123), (f, 456)]);
+        assert_eq!(results, &[(e, A(123)), (f, A(456))]);
     }
 
     #[test]
     fn par_for_each_dense() {
         let mut world = World::new();
         let task_pool = TaskPool::default();
-        let e1 = world.spawn().insert(1).id();
-        let e2 = world.spawn().insert(2).id();
-        let e3 = world.spawn().insert(3).id();
-        let e4 = world.spawn().insert_bundle((4, true)).id();
-        let e5 = world.spawn().insert_bundle((5, true)).id();
+        let e1 = world.spawn().insert(A(1)).id();
+        let e2 = world.spawn().insert(A(2)).id();
+        let e3 = world.spawn().insert(A(3)).id();
+        let e4 = world.spawn().insert_bundle((A(4), B(1))).id();
+        let e5 = world.spawn().insert_bundle((A(5), B(1))).id();
         let results = Arc::new(Mutex::new(Vec::new()));
         world
-            .query::<(Entity, &i32)>()
-            .par_for_each(&world, &task_pool, 2, |(e, &i)| results.lock().push((e, i)));
+            .query::<(Entity, &A)>()
+            .par_for_each(&world, &task_pool, 2, |(e, &A(i))| {
+                results.lock().push((e, i))
+            });
         results.lock().sort();
         assert_eq!(
             &*results.lock(),
@@ -307,19 +385,20 @@ mod tests {
     #[test]
     fn par_for_each_sparse() {
         let mut world = World::new();
-        world
-            .register_component(ComponentDescriptor::new::<i32>(StorageType::SparseSet))
-            .unwrap();
+
         let task_pool = TaskPool::default();
-        let e1 = world.spawn().insert(1).id();
-        let e2 = world.spawn().insert(2).id();
-        let e3 = world.spawn().insert(3).id();
-        let e4 = world.spawn().insert_bundle((4, true)).id();
-        let e5 = world.spawn().insert_bundle((5, true)).id();
+        let e1 = world.spawn().insert(SparseStored(1)).id();
+        let e2 = world.spawn().insert(SparseStored(2)).id();
+        let e3 = world.spawn().insert(SparseStored(3)).id();
+        let e4 = world.spawn().insert_bundle((SparseStored(4), A(1))).id();
+        let e5 = world.spawn().insert_bundle((SparseStored(5), A(1))).id();
         let results = Arc::new(Mutex::new(Vec::new()));
-        world
-            .query::<(Entity, &i32)>()
-            .par_for_each(&world, &task_pool, 2, |(e, &i)| results.lock().push((e, i)));
+        world.query::<(Entity, &SparseStored)>().par_for_each(
+            &world,
+            &task_pool,
+            2,
+            |(e, &SparseStored(i))| results.lock().push((e, i)),
+        );
         results.lock().sort();
         assert_eq!(
             &*results.lock(),
@@ -330,194 +409,223 @@ mod tests {
     #[test]
     fn query_missing_component() {
         let mut world = World::new();
-        world.spawn().insert_bundle(("abc", 123));
-        world.spawn().insert_bundle(("def", 456));
-        assert!(world.query::<(&bool, &i32)>().iter(&world).next().is_none());
+        world.spawn().insert_bundle((TableStored("abc"), A(123)));
+        world.spawn().insert_bundle((TableStored("def"), A(456)));
+        assert!(world.query::<(&B, &A)>().iter(&world).next().is_none());
     }
 
     #[test]
     fn query_sparse_component() {
         let mut world = World::new();
-        world.spawn().insert_bundle(("abc", 123));
-        let f = world.spawn().insert_bundle(("def", 456, true)).id();
+        world.spawn().insert_bundle((TableStored("abc"), A(123)));
+        let f = world
+            .spawn()
+            .insert_bundle((TableStored("def"), A(456), B(1)))
+            .id();
         let ents = world
-            .query::<(Entity, &bool)>()
+            .query::<(Entity, &B)>()
             .iter(&world)
             .map(|(e, &b)| (e, b))
             .collect::<Vec<_>>();
-        assert_eq!(ents, &[(f, true)]);
+        assert_eq!(ents, &[(f, B(1))]);
     }
 
     #[test]
     fn query_filter_with() {
         let mut world = World::new();
-        world.spawn().insert_bundle((123u32, 1.0f32));
-        world.spawn().insert(456u32);
+        world.spawn().insert_bundle((A(123), B(1)));
+        world.spawn().insert(A(456));
         let result = world
-            .query_filtered::<&u32, With<f32>>()
+            .query_filtered::<&A, With<B>>()
             .iter(&world)
             .cloned()
             .collect::<Vec<_>>();
-        assert_eq!(result, vec![123]);
+        assert_eq!(result, vec![A(123)]);
     }
 
     #[test]
     fn query_filter_with_for_each() {
         let mut world = World::new();
-        world.spawn().insert_bundle((123u32, 1.0f32));
-        world.spawn().insert(456u32);
+        world.spawn().insert_bundle((A(123), B(1)));
+        world.spawn().insert(A(456));
 
         let mut results = Vec::new();
         world
-            .query_filtered::<&u32, With<f32>>()
+            .query_filtered::<&A, With<B>>()
             .for_each(&world, |i| results.push(*i));
-        assert_eq!(results, vec![123]);
+        assert_eq!(results, vec![A(123)]);
     }
 
     #[test]
     fn query_filter_with_sparse() {
         let mut world = World::new();
-        world
-            .register_component(ComponentDescriptor::new::<f32>(StorageType::SparseSet))
-            .unwrap();
-        world.spawn().insert_bundle((123u32, 1.0f32));
-        world.spawn().insert(456u32);
+
+        world.spawn().insert_bundle((A(123), SparseStored(321)));
+        world.spawn().insert(A(456));
         let result = world
-            .query_filtered::<&u32, With<f32>>()
+            .query_filtered::<&A, With<SparseStored>>()
             .iter(&world)
             .cloned()
             .collect::<Vec<_>>();
-        assert_eq!(result, vec![123]);
+        assert_eq!(result, vec![A(123)]);
     }
 
     #[test]
     fn query_filter_with_sparse_for_each() {
         let mut world = World::new();
-        world
-            .register_component(ComponentDescriptor::new::<f32>(StorageType::SparseSet))
-            .unwrap();
-        world.spawn().insert_bundle((123u32, 1.0f32));
-        world.spawn().insert(456u32);
+
+        world.spawn().insert_bundle((A(123), SparseStored(321)));
+        world.spawn().insert(A(456));
         let mut results = Vec::new();
         world
-            .query_filtered::<&u32, With<f32>>()
+            .query_filtered::<&A, With<SparseStored>>()
             .for_each(&world, |i| results.push(*i));
-        assert_eq!(results, vec![123]);
+        assert_eq!(results, vec![A(123)]);
     }
 
     #[test]
     fn query_filter_without() {
         let mut world = World::new();
-        world.spawn().insert_bundle((123u32, 1.0f32));
-        world.spawn().insert(456u32);
+        world.spawn().insert_bundle((A(123), B(321)));
+        world.spawn().insert(A(456));
         let result = world
-            .query_filtered::<&u32, Without<f32>>()
+            .query_filtered::<&A, Without<B>>()
             .iter(&world)
             .cloned()
             .collect::<Vec<_>>();
-        assert_eq!(result, vec![456]);
+        assert_eq!(result, vec![A(456)]);
     }
 
     #[test]
     fn query_optional_component_table() {
         let mut world = World::new();
-        let e = world.spawn().insert_bundle(("abc", 123)).id();
-        let f = world.spawn().insert_bundle(("def", 456, true)).id();
+        let e = world
+            .spawn()
+            .insert_bundle((TableStored("abc"), A(123)))
+            .id();
+        let f = world
+            .spawn()
+            .insert_bundle((TableStored("def"), A(456), B(1)))
+            .id();
         // this should be skipped
-        world.spawn().insert("abc");
+        world.spawn().insert(TableStored("abc"));
         let ents = world
-            .query::<(Entity, Option<&bool>, &i32)>()
+            .query::<(Entity, Option<&B>, &A)>()
             .iter(&world)
             .map(|(e, b, &i)| (e, b.copied(), i))
             .collect::<Vec<_>>();
-        assert_eq!(ents, &[(e, None, 123), (f, Some(true), 456)]);
+        assert_eq!(ents, &[(e, None, A(123)), (f, Some(B(1)), A(456))]);
     }
 
     #[test]
     fn query_optional_component_sparse() {
         let mut world = World::new();
-        world
-            .register_component(ComponentDescriptor::new::<bool>(StorageType::SparseSet))
-            .unwrap();
-        let e = world.spawn().insert_bundle(("abc", 123)).id();
-        let f = world.spawn().insert_bundle(("def", 456, true)).id();
+
+        let e = world
+            .spawn()
+            .insert_bundle((TableStored("abc"), A(123)))
+            .id();
+        let f = world
+            .spawn()
+            .insert_bundle((TableStored("def"), A(456), SparseStored(1)))
+            .id();
         // // this should be skipped
-        // world.spawn().insert("abc");
+        // SparseStored(1).spawn().insert("abc");
         let ents = world
-            .query::<(Entity, Option<&bool>, &i32)>()
+            .query::<(Entity, Option<&SparseStored>, &A)>()
             .iter(&world)
             .map(|(e, b, &i)| (e, b.copied(), i))
             .collect::<Vec<_>>();
-        assert_eq!(ents, &[(e, None, 123), (f, Some(true), 456)]);
+        assert_eq!(
+            ents,
+            &[(e, None, A(123)), (f, Some(SparseStored(1)), A(456))]
+        );
     }
 
     #[test]
     fn query_optional_component_sparse_no_match() {
         let mut world = World::new();
+
+        //TODO: fix component registration in queries so this isn't needed.
         world
-            .register_component(ComponentDescriptor::new::<bool>(StorageType::SparseSet))
+            .register_component(bevy_ecs::component::ComponentDescriptor::new::<SparseStored>())
             .unwrap();
-        let e = world.spawn().insert_bundle(("abc", 123)).id();
-        let f = world.spawn().insert_bundle(("def", 456)).id();
+
+        let e = world
+            .spawn()
+            .insert_bundle((TableStored("abc"), A(123)))
+            .id();
+        let f = world
+            .spawn()
+            .insert_bundle((TableStored("def"), A(456)))
+            .id();
         // // this should be skipped
-        world.spawn().insert("abc");
+        world.spawn().insert(TableStored("abc"));
         let ents = world
-            .query::<(Entity, Option<&bool>, &i32)>()
+            .query::<(Entity, Option<&SparseStored>, &A)>()
             .iter(&world)
             .map(|(e, b, &i)| (e, b.copied(), i))
             .collect::<Vec<_>>();
-        assert_eq!(ents, &[(e, None, 123), (f, None, 456)]);
+        assert_eq!(ents, &[(e, None, A(123)), (f, None, A(456))]);
     }
 
     #[test]
     fn add_remove_components() {
         let mut world = World::new();
-        let e1 = world.spawn().insert(42).insert_bundle((true, "abc")).id();
-        let e2 = world.spawn().insert(0).insert_bundle((false, "xyz")).id();
+        let e1 = world
+            .spawn()
+            .insert(A(1))
+            .insert_bundle((B(3), TableStored("abc")))
+            .id();
+        let e2 = world
+            .spawn()
+            .insert(A(2))
+            .insert_bundle((B(4), TableStored("xyz")))
+            .id();
 
         assert_eq!(
             world
-                .query::<(Entity, &i32, &bool)>()
+                .query::<(Entity, &A, &B)>()
                 .iter(&world)
                 .map(|(e, &i, &b)| (e, i, b))
                 .collect::<Vec<_>>(),
-            &[(e1, 42, true), (e2, 0, false)]
+            &[(e1, A(1), B(3)), (e2, A(2), B(4))]
         );
 
-        assert_eq!(world.entity_mut(e1).remove::<i32>(), Some(42));
+        assert_eq!(world.entity_mut(e1).remove::<A>(), Some(A(1)));
         assert_eq!(
             world
-                .query::<(Entity, &i32, &bool)>()
+                .query::<(Entity, &A, &B)>()
                 .iter(&world)
                 .map(|(e, &i, &b)| (e, i, b))
                 .collect::<Vec<_>>(),
-            &[(e2, 0, false)]
+            &[(e2, A(2), B(4))]
         );
         assert_eq!(
             world
-                .query::<(Entity, &bool, &&str)>()
+                .query::<(Entity, &B, &TableStored)>()
                 .iter(&world)
-                .map(|(e, &b, &s)| (e, b, s))
+                .map(|(e, &B(b), &TableStored(s))| (e, b, s))
                 .collect::<Vec<_>>(),
-            &[(e2, false, "xyz"), (e1, true, "abc")]
+            &[(e2, 4, "xyz"), (e1, 3, "abc")]
         );
-        world.entity_mut(e1).insert(43);
+        world.entity_mut(e1).insert(A(43));
         assert_eq!(
             world
-                .query::<(Entity, &i32, &bool)>()
+                .query::<(Entity, &A, &B)>()
                 .iter(&world)
                 .map(|(e, &i, &b)| (e, i, b))
                 .collect::<Vec<_>>(),
-            &[(e2, 0, false), (e1, 43, true)]
+            &[(e2, A(2), B(4)), (e1, A(43), B(3))]
         );
-        world.entity_mut(e1).insert(1.0f32);
+        world.entity_mut(e1).insert(C);
         assert_eq!(
             world
-                .query::<(Entity, &f32)>()
+                .query::<(Entity, &C)>()
                 .iter(&world)
                 .map(|(e, &f)| (e, f))
                 .collect::<Vec<_>>(),
-            &[(e1, 1.0)]
+            &[(e1, C)]
         );
     }
 
@@ -526,53 +634,57 @@ mod tests {
         let mut world = World::default();
         let mut entities = Vec::with_capacity(10_000);
         for _ in 0..1000 {
-            entities.push(world.spawn().insert(0.0f32).id());
+            entities.push(world.spawn().insert(B(0)).id());
         }
 
         for (i, entity) in entities.iter().cloned().enumerate() {
-            world.entity_mut(entity).insert(i);
+            world.entity_mut(entity).insert(A(i));
         }
 
         for (i, entity) in entities.iter().cloned().enumerate() {
-            assert_eq!(world.entity_mut(entity).remove::<usize>(), Some(i));
+            assert_eq!(world.entity_mut(entity).remove::<A>(), Some(A(i)));
         }
     }
 
     #[test]
     fn sparse_set_add_remove_many() {
         let mut world = World::default();
-        world
-            .register_component(ComponentDescriptor::new::<usize>(StorageType::SparseSet))
-            .unwrap();
+
         let mut entities = Vec::with_capacity(1000);
         for _ in 0..4 {
-            entities.push(world.spawn().insert(0.0f32).id());
+            entities.push(world.spawn().insert(A(2)).id());
         }
 
         for (i, entity) in entities.iter().cloned().enumerate() {
-            world.entity_mut(entity).insert(i);
+            world.entity_mut(entity).insert(SparseStored(i as u32));
         }
 
         for (i, entity) in entities.iter().cloned().enumerate() {
-            assert_eq!(world.entity_mut(entity).remove::<usize>(), Some(i));
+            assert_eq!(
+                world.entity_mut(entity).remove::<SparseStored>(),
+                Some(SparseStored(i as u32))
+            );
         }
     }
 
     #[test]
     fn remove_missing() {
         let mut world = World::new();
-        let e = world.spawn().insert_bundle(("abc", 123)).id();
-        assert!(world.entity_mut(e).remove::<bool>().is_none());
+        let e = world
+            .spawn()
+            .insert_bundle((TableStored("abc"), A(123)))
+            .id();
+        assert!(world.entity_mut(e).remove::<B>().is_none());
     }
 
     #[test]
     fn spawn_batch() {
         let mut world = World::new();
-        world.spawn_batch((0..100).map(|x| (x, "abc")));
+        world.spawn_batch((0..100).map(|x| (A(x), TableStored("abc"))));
         let values = world
-            .query::<&i32>()
+            .query::<&A>()
             .iter(&world)
-            .copied()
+            .map(|v| v.0)
             .collect::<Vec<_>>();
         let expected = (0..100).collect::<Vec<_>>();
         assert_eq!(values, expected);
@@ -581,17 +693,26 @@ mod tests {
     #[test]
     fn query_get() {
         let mut world = World::new();
-        let a = world.spawn().insert_bundle(("abc", 123)).id();
-        let b = world.spawn().insert_bundle(("def", 456)).id();
-        let c = world.spawn().insert_bundle(("ghi", 789, true)).id();
+        let a = world
+            .spawn()
+            .insert_bundle((TableStored("abc"), A(123)))
+            .id();
+        let b = world
+            .spawn()
+            .insert_bundle((TableStored("def"), A(456)))
+            .id();
+        let c = world
+            .spawn()
+            .insert_bundle((TableStored("ghi"), A(789), B(1)))
+            .id();
 
-        let mut i32_query = world.query::<&i32>();
-        assert_eq!(i32_query.get(&world, a).unwrap(), &123);
-        assert_eq!(i32_query.get(&world, b).unwrap(), &456);
+        let mut i32_query = world.query::<&A>();
+        assert_eq!(i32_query.get(&world, a).unwrap().0, 123);
+        assert_eq!(i32_query.get(&world, b).unwrap().0, 456);
 
-        let mut i32_bool_query = world.query::<(&i32, &bool)>();
+        let mut i32_bool_query = world.query::<(&A, &B)>();
         assert!(i32_bool_query.get(&world, a).is_err());
-        assert_eq!(i32_bool_query.get(&world, c).unwrap(), (&789, &true));
+        assert_eq!(i32_bool_query.get(&world, c).unwrap(), (&A(789), &B(1)));
         assert!(world.despawn(a));
         assert!(i32_query.get(&world, a).is_err());
     }
@@ -599,53 +720,49 @@ mod tests {
     #[test]
     fn remove_tracking() {
         let mut world = World::new();
-        world
-            .register_component(ComponentDescriptor::new::<&'static str>(
-                StorageType::SparseSet,
-            ))
-            .unwrap();
-        let a = world.spawn().insert_bundle(("abc", 123)).id();
-        let b = world.spawn().insert_bundle(("abc", 123)).id();
+
+        let a = world.spawn().insert_bundle((SparseStored(0), A(123))).id();
+        let b = world.spawn().insert_bundle((SparseStored(1), A(123))).id();
 
         world.entity_mut(a).despawn();
         assert_eq!(
-            world.removed::<i32>().collect::<Vec<_>>(),
+            world.removed::<A>().collect::<Vec<_>>(),
             &[a],
             "despawning results in 'removed component' state for table components"
         );
         assert_eq!(
-            world.removed::<&'static str>().collect::<Vec<_>>(),
+            world.removed::<SparseStored>().collect::<Vec<_>>(),
             &[a],
             "despawning results in 'removed component' state for sparse set components"
         );
 
-        world.entity_mut(b).insert(10.0);
+        world.entity_mut(b).insert(B(1));
         assert_eq!(
-            world.removed::<i32>().collect::<Vec<_>>(),
+            world.removed::<A>().collect::<Vec<_>>(),
             &[a],
             "archetype moves does not result in 'removed component' state"
         );
 
-        world.entity_mut(b).remove::<i32>();
+        world.entity_mut(b).remove::<A>();
         assert_eq!(
-            world.removed::<i32>().collect::<Vec<_>>(),
+            world.removed::<A>().collect::<Vec<_>>(),
             &[a, b],
             "removing a component results in a 'removed component' state"
         );
 
         world.clear_trackers();
         assert_eq!(
-            world.removed::<i32>().collect::<Vec<_>>(),
+            world.removed::<A>().collect::<Vec<_>>(),
             &[],
             "clearning trackers clears removals"
         );
         assert_eq!(
-            world.removed::<&'static str>().collect::<Vec<_>>(),
+            world.removed::<SparseStored>().collect::<Vec<_>>(),
             &[],
             "clearning trackers clears removals"
         );
         assert_eq!(
-            world.removed::<f64>().collect::<Vec<_>>(),
+            world.removed::<B>().collect::<Vec<_>>(),
             &[],
             "clearning trackers clears removals"
         );
@@ -674,61 +791,49 @@ mod tests {
     #[test]
     fn added_tracking() {
         let mut world = World::new();
-        let a = world.spawn().insert(123i32).id();
+        let a = world.spawn().insert(A(123)).id();
 
-        assert_eq!(world.query::<&i32>().iter(&world).count(), 1);
+        assert_eq!(world.query::<&A>().iter(&world).count(), 1);
         assert_eq!(
-            world
-                .query_filtered::<(), Added<i32>>()
-                .iter(&world)
-                .count(),
+            world.query_filtered::<(), Added<A>>().iter(&world).count(),
             1
         );
-        assert_eq!(world.query::<&i32>().iter(&world).count(), 1);
+        assert_eq!(world.query::<&A>().iter(&world).count(), 1);
         assert_eq!(
-            world
-                .query_filtered::<(), Added<i32>>()
-                .iter(&world)
-                .count(),
+            world.query_filtered::<(), Added<A>>().iter(&world).count(),
             1
         );
-        assert!(world.query::<&i32>().get(&world, a).is_ok());
+        assert!(world.query::<&A>().get(&world, a).is_ok());
         assert!(world
-            .query_filtered::<(), Added<i32>>()
+            .query_filtered::<(), Added<A>>()
             .get(&world, a)
             .is_ok());
-        assert!(world.query::<&i32>().get(&world, a).is_ok());
+        assert!(world.query::<&A>().get(&world, a).is_ok());
         assert!(world
-            .query_filtered::<(), Added<i32>>()
+            .query_filtered::<(), Added<A>>()
             .get(&world, a)
             .is_ok());
 
         world.clear_trackers();
 
-        assert_eq!(world.query::<&i32>().iter(&world).count(), 1);
+        assert_eq!(world.query::<&A>().iter(&world).count(), 1);
         assert_eq!(
-            world
-                .query_filtered::<(), Added<i32>>()
-                .iter(&world)
-                .count(),
+            world.query_filtered::<(), Added<A>>().iter(&world).count(),
             0
         );
-        assert_eq!(world.query::<&i32>().iter(&world).count(), 1);
+        assert_eq!(world.query::<&A>().iter(&world).count(), 1);
         assert_eq!(
-            world
-                .query_filtered::<(), Added<i32>>()
-                .iter(&world)
-                .count(),
+            world.query_filtered::<(), Added<A>>().iter(&world).count(),
             0
         );
-        assert!(world.query::<&i32>().get(&world, a).is_ok());
+        assert!(world.query::<&A>().get(&world, a).is_ok());
         assert!(world
-            .query_filtered::<(), Added<i32>>()
+            .query_filtered::<(), Added<A>>()
             .get(&world, a)
             .is_err());
-        assert!(world.query::<&i32>().get(&world, a).is_ok());
+        assert!(world.query::<&A>().get(&world, a).is_ok());
         assert!(world
-            .query_filtered::<(), Added<i32>>()
+            .query_filtered::<(), Added<A>>()
             .get(&world, a)
             .is_err());
     }
@@ -976,36 +1081,39 @@ mod tests {
     #[test]
     fn remove_intersection() {
         let mut world = World::default();
-        let e1 = world.spawn().insert_bundle((1, 1.0, "a")).id();
+        let e1 = world
+            .spawn()
+            .insert_bundle((A(1), B(1), TableStored("a")))
+            .id();
 
         let mut e = world.entity_mut(e1);
-        assert_eq!(e.get::<&'static str>(), Some(&"a"));
-        assert_eq!(e.get::<i32>(), Some(&1));
-        assert_eq!(e.get::<f64>(), Some(&1.0));
+        assert_eq!(e.get::<TableStored>(), Some(&TableStored("a")));
+        assert_eq!(e.get::<A>(), Some(&A(1)));
+        assert_eq!(e.get::<B>(), Some(&B(1)));
         assert_eq!(
-            e.get::<usize>(),
+            e.get::<C>(),
             None,
-            "usize is not in the entity, so it should not exist"
+            "C is not in the entity, so it should not exist"
         );
 
-        e.remove_bundle_intersection::<(i32, f64, usize)>();
+        e.remove_bundle_intersection::<(A, B, C)>();
         assert_eq!(
-            e.get::<&'static str>(),
-            Some(&"a"),
-            "&'static str is not in the removed bundle, so it should exist"
+            e.get::<TableStored>(),
+            Some(&TableStored("a")),
+            "TableStored is not in the removed bundle, so it should exist"
         );
         assert_eq!(
-            e.get::<i32>(),
+            e.get::<A>(),
             None,
             "i32 is in the removed bundle, so it should not exist"
         );
         assert_eq!(
-            e.get::<f64>(),
+            e.get::<B>(),
             None,
             "f64 is in the removed bundle, so it should not exist"
         );
         assert_eq!(
-            e.get::<usize>(),
+            e.get::<C>(),
             None,
             "usize is in the removed bundle, so it should not exist"
         );
@@ -1014,48 +1122,57 @@ mod tests {
     #[test]
     fn remove_bundle() {
         let mut world = World::default();
-        world.spawn().insert_bundle((1, 1.0, 1usize)).id();
-        let e2 = world.spawn().insert_bundle((2, 2.0, 2usize)).id();
-        world.spawn().insert_bundle((3, 3.0, 3usize)).id();
+        world
+            .spawn()
+            .insert_bundle((A(1), B(1), TableStored("1")))
+            .id();
+        let e2 = world
+            .spawn()
+            .insert_bundle((A(2), B(2), TableStored("2")))
+            .id();
+        world
+            .spawn()
+            .insert_bundle((A(3), B(3), TableStored("3")))
+            .id();
 
-        let mut query = world.query::<(&f64, &usize)>();
+        let mut query = world.query::<(&B, &TableStored)>();
         let results = query
             .iter(&world)
-            .map(|(a, b)| (*a, *b))
+            .map(|(a, b)| (a.0, b.0))
             .collect::<Vec<_>>();
-        assert_eq!(results, vec![(1.0, 1usize), (2.0, 2usize), (3.0, 3usize),]);
+        assert_eq!(results, vec![(1, "1"), (2, "2"), (3, "3"),]);
 
         let removed_bundle = world
             .entity_mut(e2)
-            .remove_bundle::<(f64, usize)>()
+            .remove_bundle::<(B, TableStored)>()
             .unwrap();
-        assert_eq!(removed_bundle, (2.0, 2usize));
+        assert_eq!(removed_bundle, (B(2), TableStored("2")));
 
         let results = query
             .iter(&world)
-            .map(|(a, b)| (*a, *b))
+            .map(|(a, b)| (a.0, b.0))
             .collect::<Vec<_>>();
-        assert_eq!(results, vec![(1.0, 1usize), (3.0, 3usize),]);
+        assert_eq!(results, vec![(1, "1"), (3, "3"),]);
 
-        let mut i32_query = world.query::<&i32>();
-        let results = i32_query.iter(&world).cloned().collect::<Vec<_>>();
+        let mut a_query = world.query::<&A>();
+        let results = a_query.iter(&world).map(|a| a.0).collect::<Vec<_>>();
         assert_eq!(results, vec![1, 3, 2]);
 
         let entity_ref = world.entity(e2);
         assert_eq!(
-            entity_ref.get::<i32>(),
-            Some(&2),
-            "i32 is not in the removed bundle, so it should exist"
+            entity_ref.get::<A>(),
+            Some(&A(2)),
+            "A is not in the removed bundle, so it should exist"
         );
         assert_eq!(
-            entity_ref.get::<f64>(),
+            entity_ref.get::<B>(),
             None,
-            "f64 is in the removed bundle, so it should not exist"
+            "B is in the removed bundle, so it should not exist"
         );
         assert_eq!(
-            entity_ref.get::<usize>(),
+            entity_ref.get::<TableStored>(),
             None,
-            "usize is in the removed bundle, so it should not exist"
+            "TableStored is in the removed bundle, so it should not exist"
         );
     }
 
@@ -1120,7 +1237,7 @@ mod tests {
     #[should_panic]
     fn duplicate_components_panic() {
         let mut world = World::new();
-        world.spawn().insert_bundle((1, 2));
+        world.spawn().insert_bundle((A(1), A(2)));
     }
 
     #[test]
@@ -1149,7 +1266,7 @@ mod tests {
     fn multiple_worlds_same_query_iter() {
         let mut world_a = World::new();
         let world_b = World::new();
-        let mut query = world_a.query::<&i32>();
+        let mut query = world_a.query::<&A>();
         query.iter(&world_a);
         query.iter(&world_b);
     }
@@ -1157,19 +1274,19 @@ mod tests {
     #[test]
     fn query_filters_dont_collide_with_fetches() {
         let mut world = World::new();
-        world.query_filtered::<&mut i32, Changed<i32>>();
+        world.query_filtered::<&mut A, Changed<A>>();
     }
 
     #[test]
     fn filtered_query_access() {
         let mut world = World::new();
-        let query = world.query_filtered::<&mut i32, Changed<f64>>();
+        let query = world.query_filtered::<&mut A, Changed<B>>();
 
         let mut expected = FilteredAccess::<ComponentId>::default();
-        let i32_id = world.components.get_id(TypeId::of::<i32>()).unwrap();
-        let f64_id = world.components.get_id(TypeId::of::<f64>()).unwrap();
-        expected.add_write(i32_id);
-        expected.add_read(f64_id);
+        let a_id = world.components.get_id(TypeId::of::<A>()).unwrap();
+        let b_id = world.components.get_id(TypeId::of::<B>()).unwrap();
+        expected.add_write(a_id);
+        expected.add_read(b_id);
         assert!(
             query.component_access.eq(&expected),
             "ComponentId access from query fetch and query filter should be combined"
@@ -1181,7 +1298,7 @@ mod tests {
     fn multiple_worlds_same_query_get() {
         let mut world_a = World::new();
         let world_b = World::new();
-        let mut query = world_a.query::<&i32>();
+        let mut query = world_a.query::<&A>();
         let _ = query.get(&world_a, Entity::new(0));
         let _ = query.get(&world_b, Entity::new(0));
     }
@@ -1191,7 +1308,7 @@ mod tests {
     fn multiple_worlds_same_query_for_each() {
         let mut world_a = World::new();
         let world_b = World::new();
-        let mut query = world_a.query::<&i32>();
+        let mut query = world_a.query::<&A>();
         query.for_each(&world_a, |_| {});
         query.for_each(&world_b, |_| {});
     }
@@ -1225,9 +1342,9 @@ mod tests {
         let (dropck1, dropped1) = DropCk::new_pair();
         let (dropck2, dropped2) = DropCk::new_pair();
         let mut world = World::default();
-        world
-            .register_component(ComponentDescriptor::new::<DropCk>(StorageType::SparseSet))
-            .unwrap();
+        // world
+        //     .register_component(ComponentDescriptor::new::<DropCk>(StorageType::SparseSet))
+        //     .unwrap();
         world.spawn().insert(dropck1).insert(dropck2);
         assert_eq!(dropped1.load(Ordering::Relaxed), 1);
         assert_eq!(dropped2.load(Ordering::Relaxed), 0);
@@ -1239,15 +1356,13 @@ mod tests {
     #[test]
     fn clear_entities() {
         let mut world = World::default();
-        world
-            .register_component(ComponentDescriptor::new::<f32>(StorageType::SparseSet))
-            .unwrap();
+
         world.insert_resource::<i32>(0);
-        world.spawn().insert(1u32);
-        world.spawn().insert(1.0f32);
+        world.spawn().insert(A(1));
+        world.spawn().insert(SparseStored(1));
 
-        let mut q1 = world.query::<&u32>();
-        let mut q2 = world.query::<&f32>();
+        let mut q1 = world.query::<&A>();
+        let mut q2 = world.query::<&SparseStored>();
 
         assert_eq!(q1.iter(&world).len(), 1);
         assert_eq!(q2.iter(&world).len(), 1);
@@ -1282,8 +1397,8 @@ mod tests {
         let mut world_a = World::default();
         let mut world_b = World::default();
 
-        let e1 = world_a.spawn().insert(1u32).id();
-        let e2 = world_a.spawn().insert(2u32).id();
+        let e1 = world_a.spawn().insert(A(1)).id();
+        let e2 = world_a.spawn().insert(A(2)).id();
         let e3 = world_a.entities().reserve_entity();
         world_a.flush();
 
@@ -1293,7 +1408,7 @@ mod tests {
             .reserve_entities(world_a_max_entities as u32);
         world_b.entities.flush_as_invalid();
 
-        let e4 = world_b.spawn().insert(4u32).id();
+        let e4 = world_b.spawn().insert(A(4)).id();
         assert_eq!(
             e4,
             Entity {
@@ -1302,31 +1417,31 @@ mod tests {
             },
             "new entity is created immediately after world_a's max entity"
         );
-        assert!(world_b.get::<u32>(e1).is_none());
+        assert!(world_b.get::<A>(e1).is_none());
         assert!(world_b.get_entity(e1).is_none());
 
-        assert!(world_b.get::<u32>(e2).is_none());
+        assert!(world_b.get::<A>(e2).is_none());
         assert!(world_b.get_entity(e2).is_none());
 
-        assert!(world_b.get::<u32>(e3).is_none());
+        assert!(world_b.get::<A>(e3).is_none());
         assert!(world_b.get_entity(e3).is_none());
 
-        world_b.get_or_spawn(e1).unwrap().insert(1.0f32);
+        world_b.get_or_spawn(e1).unwrap().insert(B(1));
         assert_eq!(
-            world_b.get::<f32>(e1),
-            Some(&1.0f32),
+            world_b.get::<B>(e1),
+            Some(&B(1)),
             "spawning into 'world_a' entities works"
         );
 
-        world_b.get_or_spawn(e4).unwrap().insert(4.0f32);
+        world_b.get_or_spawn(e4).unwrap().insert(B(4));
         assert_eq!(
-            world_b.get::<f32>(e4),
-            Some(&4.0f32),
+            world_b.get::<B>(e4),
+            Some(&B(4)),
             "spawning into existing `world_b` entities works"
         );
         assert_eq!(
-            world_b.get::<u32>(e4),
-            Some(&4u32),
+            world_b.get::<A>(e4),
+            Some(&A(4)),
             "spawning into existing `world_b` entities works"
         );
 
@@ -1339,13 +1454,13 @@ mod tests {
             "attempting to spawn on top of an entity with a mismatched entity generation fails"
         );
         assert_eq!(
-            world_b.get::<f32>(e4),
-            Some(&4.0f32),
+            world_b.get::<B>(e4),
+            Some(&B(4)),
             "failed mismatched spawn doesn't change existing entity"
         );
         assert_eq!(
-            world_b.get::<u32>(e4),
-            Some(&4u32),
+            world_b.get::<A>(e4),
+            Some(&A(4)),
             "failed mismatched spawn doesn't change existing entity"
         );
 
@@ -1356,10 +1471,10 @@ mod tests {
         world_b
             .get_or_spawn(high_non_existent_entity)
             .unwrap()
-            .insert(10.0f32);
+            .insert(B(10));
         assert_eq!(
-            world_b.get::<f32>(high_non_existent_entity),
-            Some(&10.0f32),
+            world_b.get::<B>(high_non_existent_entity),
+            Some(&B(10)),
             "inserting into newly allocated high / non-continous entity id works"
         );
 
@@ -1488,4 +1603,3 @@ mod tests {
         );
     }
 }
-*/
diff --git a/crates/bevy_ecs/src/schedule/executor_parallel.rs b/crates/bevy_ecs/src/schedule/executor_parallel.rs
index 42cd1318980c6..94cb60a5f37da 100644
--- a/crates/bevy_ecs/src/schedule/executor_parallel.rs
+++ b/crates/bevy_ecs/src/schedule/executor_parallel.rs
@@ -321,6 +321,11 @@ mod tests {
     };
     use async_channel::Receiver;
 
+    use crate as bevy_ecs;
+    use crate::component::Component;
+    #[derive(Component)]
+    struct W<T>(T);
+
     fn receive_events(world: &World) -> Vec<SchedulingEvent> {
         let mut events = Vec::new();
         while let Ok(event) = world
@@ -381,9 +386,9 @@ mod tests {
     #[test]
     fn queries() {
         let mut world = World::new();
-        world.spawn().insert(0usize);
-        fn wants_mut(_: Query<&mut usize>) {}
-        fn wants_ref(_: Query<&usize>) {}
+        world.spawn().insert(W(0usize));
+        fn wants_mut(_: Query<&mut W<usize>>) {}
+        fn wants_ref(_: Query<&W<usize>>) {}
         let mut stage = SystemStage::parallel()
             .with_system(wants_mut)
             .with_system(wants_mut);
@@ -406,9 +411,9 @@ mod tests {
         stage.run(&mut world);
         assert_eq!(receive_events(&world), vec![StartedSystems(2),]);
         let mut world = World::new();
-        world.spawn().insert_bundle((0usize, 0u32, 0f32));
-        fn wants_mut_usize(_: Query<(&mut usize, &f32)>) {}
-        fn wants_mut_u32(_: Query<(&mut u32, &f32)>) {}
+        world.spawn().insert_bundle((W(0usize), W(0u32), W(0f32)));
+        fn wants_mut_usize(_: Query<(&mut W<usize>, &W<f32>)>) {}
+        fn wants_mut_u32(_: Query<(&mut W<u32>, &W<f32>)>) {}
         let mut stage = SystemStage::parallel()
             .with_system(wants_mut_usize)
             .with_system(wants_mut_u32);
diff --git a/crates/bevy_ecs/src/schedule/stage.rs b/crates/bevy_ecs/src/schedule/stage.rs
index 80ab641db7b19..ddf956553b81f 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -904,6 +904,11 @@ mod tests {
         world::World,
     };
 
+    use crate as bevy_ecs;
+    use crate::component::Component;
+    #[derive(Component)]
+    struct W<T>(T);
+
     fn make_exclusive(tag: usize) -> impl FnMut(&mut World) {
         move |world| world.get_resource_mut::<Vec<usize>>().unwrap().push(tag)
     }
@@ -1572,7 +1577,7 @@ mod tests {
 
         fn empty() {}
         fn resource(_: ResMut<usize>) {}
-        fn component(_: Query<&mut f32>) {}
+        fn component(_: Query<&mut W<f32>>) {}
 
         let mut world = World::new();
 
@@ -1956,7 +1961,7 @@ mod tests {
         stage.run(&mut world);
         assert_eq!(*world.get_resource::<usize>().unwrap(), 1);
 
-        world.get_entity_mut(entity).unwrap().insert(1);
+        world.get_entity_mut(entity).unwrap().insert(W(1));
         stage.run(&mut world);
         assert_eq!(*world.get_resource::<usize>().unwrap(), 1);
     }
@@ -1979,7 +1984,7 @@ mod tests {
         stage.run(&mut world);
         assert_eq!(*world.get_resource::<usize>().unwrap(), 1);
 
-        world.get_entity_mut(entity).unwrap().insert(1);
+        world.get_entity_mut(entity).unwrap().insert(W(1));
         stage.run(&mut world);
         assert_eq!(*world.get_resource::<usize>().unwrap(), 1);
     }
@@ -1990,7 +1995,7 @@ mod tests {
         const MAX_DELTA: u32 = (u32::MAX / 4) * 3;
 
         let mut world = World::new();
-        world.spawn().insert(0usize);
+        world.spawn().insert(W(0usize));
         *world.change_tick.get_mut() += MAX_DELTA + 1;
 
         let mut stage = SystemStage::parallel();
@@ -2000,7 +2005,7 @@ mod tests {
         // Overflow twice
         for _ in 0..10 {
             stage.run(&mut world);
-            for tracker in world.query::<ChangeTrackers<usize>>().iter(&world) {
+            for tracker in world.query::<ChangeTrackers<W<usize>>>().iter(&world) {
                 let time_since_last_check = tracker
                     .change_tick
                     .wrapping_sub(tracker.component_ticks.added);
diff --git a/crates/bevy_ecs/src/storage/table.rs b/crates/bevy_ecs/src/storage/table.rs
index 60d41f25ad127..489fa164a01ff 100644
--- a/crates/bevy_ecs/src/storage/table.rs
+++ b/crates/bevy_ecs/src/storage/table.rs
@@ -522,12 +522,16 @@ impl IndexMut<TableId> for Tables {
 
 #[cfg(test)]
 mod tests {
+    use crate as bevy_ecs;
+    use crate::component::Component;
     use crate::{component::Components, entity::Entity, storage::Table};
+    #[derive(Component)]
+    struct W<T>(T);
 
     #[test]
     fn table() {
         let mut components = Components::default();
-        let component_id = components.get_or_insert_id::<usize>();
+        let component_id = components.get_or_insert_id::<W<usize>>();
         let columns = &[component_id];
         let mut table = Table::with_capacity(0, columns.len());
         table.add_column(components.get_info(component_id).unwrap());
diff --git a/crates/bevy_ecs/src/system/commands/mod.rs b/crates/bevy_ecs/src/system/commands/mod.rs
index a543210c75803..87106b78de1b8 100644
--- a/crates/bevy_ecs/src/system/commands/mod.rs
+++ b/crates/bevy_ecs/src/system/commands/mod.rs
@@ -521,19 +521,22 @@ mod tests {
         }
     }
 
+    #[derive(Component)]
+    struct W<T>(T);
+
     #[test]
     fn commands() {
         let mut world = World::default();
         let mut command_queue = CommandQueue::default();
         let entity = Commands::new(&mut command_queue, &world)
-            .spawn_bundle((1u32, 2u64))
+            .spawn_bundle((W(1u32), W(2u64)))
             .id();
         command_queue.apply(&mut world);
         assert!(world.entities().len() == 1);
         let results = world
-            .query::<(&u32, &u64)>()
+            .query::<(&W<u32>, &W<u64>)>()
             .iter(&world)
-            .map(|(a, b)| (*a, *b))
+            .map(|(a, b)| (a.0, b.0))
             .collect::<Vec<_>>();
         assert_eq!(results, vec![(1u32, 2u64)]);
         // test entity despawn
@@ -544,9 +547,9 @@ mod tests {
         }
         command_queue.apply(&mut world);
         let results2 = world
-            .query::<(&u32, &u64)>()
+            .query::<(&W<u32>, &W<u64>)>()
             .iter(&world)
-            .map(|(a, b)| (*a, *b))
+            .map(|(a, b)| (a.0, b.0))
             .collect::<Vec<_>>();
         assert_eq!(results2, vec![]);
     }
@@ -562,21 +565,21 @@ mod tests {
 
         let entity = Commands::new(&mut command_queue, &world)
             .spawn()
-            .insert_bundle((1u32, 2u64, dense_dropck, sparse_dropck))
+            .insert_bundle((W(1u32), W(2u64), dense_dropck, sparse_dropck))
             .id();
         command_queue.apply(&mut world);
         let results_before = world
-            .query::<(&u32, &u64)>()
+            .query::<(&W<u32>, &W<u64>)>()
             .iter(&world)
-            .map(|(a, b)| (*a, *b))
+            .map(|(a, b)| (a.0, b.0))
             .collect::<Vec<_>>();
         assert_eq!(results_before, vec![(1u32, 2u64)]);
 
         // test component removal
         Commands::new(&mut command_queue, &world)
             .entity(entity)
-            .remove::<u32>()
-            .remove_bundle::<(u32, u64, SparseDropCk, DropCk)>();
+            .remove::<W<u32>>()
+            .remove_bundle::<(W<u32>, W<u64>, SparseDropCk, DropCk)>();
 
         assert_eq!(dense_is_dropped.load(Ordering::Relaxed), 0);
         assert_eq!(sparse_is_dropped.load(Ordering::Relaxed), 0);
@@ -585,15 +588,15 @@ mod tests {
         assert_eq!(sparse_is_dropped.load(Ordering::Relaxed), 1);
 
         let results_after = world
-            .query::<(&u32, &u64)>()
+            .query::<(&W<u32>, &W<u64>)>()
             .iter(&world)
-            .map(|(a, b)| (*a, *b))
+            .map(|(a, b)| (a.0, b.0))
             .collect::<Vec<_>>();
         assert_eq!(results_after, vec![]);
         let results_after_u64 = world
-            .query::<&u64>()
+            .query::<&W<u64>>()
             .iter(&world)
-            .copied()
+            .map(|v| v.0)
             .collect::<Vec<_>>();
         assert_eq!(results_after_u64, vec![]);
     }
diff --git a/crates/bevy_ecs/src/system/exclusive_system.rs b/crates/bevy_ecs/src/system/exclusive_system.rs
index c005b8aa07d49..496fa4e52aea0 100644
--- a/crates/bevy_ecs/src/system/exclusive_system.rs
+++ b/crates/bevy_ecs/src/system/exclusive_system.rs
@@ -133,30 +133,34 @@ mod tests {
         system::{Commands, IntoExclusiveSystem, Query, ResMut},
         world::World,
     };
+
+    #[derive(Component)]
+    struct Foo(f32);
+
     #[test]
     fn parallel_with_commands_as_exclusive() {
         let mut world = World::new();
 
         fn removal(
             mut commands: Commands,
-            query: Query<Entity, With<f32>>,
+            query: Query<Entity, With<Foo>>,
             mut counter: ResMut<usize>,
         ) {
             for entity in query.iter() {
                 *counter += 1;
-                commands.entity(entity).remove::<f32>();
+                commands.entity(entity).remove::<Foo>();
             }
         }
 
         let mut stage = SystemStage::parallel().with_system(removal);
-        world.spawn().insert(0.0f32);
+        world.spawn().insert(Foo(0.0f32));
         world.insert_resource(0usize);
         stage.run(&mut world);
         stage.run(&mut world);
         assert_eq!(*world.get_resource::<usize>().unwrap(), 1);
 
         let mut stage = SystemStage::parallel().with_system(removal.exclusive_system());
-        world.spawn().insert(0.0f32);
+        world.spawn().insert(Foo(0.0f32));
         world.insert_resource(0usize);
         stage.run(&mut world);
         stage.run(&mut world);
@@ -165,11 +169,8 @@ mod tests {
 
     #[test]
     fn update_archetype_for_exclusive_system_coerced() {
-        #[derive(Component)]
-        struct Foo;
-
         fn spawn_entity(mut commands: crate::prelude::Commands) {
-            commands.spawn().insert(Foo);
+            commands.spawn().insert(Foo(0.0));
         }
 
         fn count_entities(query: Query<&Foo>, mut res: ResMut<Vec<usize>>) {
diff --git a/crates/bevy_ecs/src/system/mod.rs b/crates/bevy_ecs/src/system/mod.rs
index 7a5622813665c..9135de3dbd198 100644
--- a/crates/bevy_ecs/src/system/mod.rs
+++ b/crates/bevy_ecs/src/system/mod.rs
@@ -47,6 +47,9 @@ mod tests {
     #[derive(Component)]
     struct F;
 
+    #[derive(Component)]
+    struct W<T>(T);
+
     #[test]
     fn simple_system() {
         fn sys(query: Query<&A>) {
@@ -341,15 +344,15 @@ mod tests {
     fn remove_tracking() {
         let mut world = World::new();
         struct Despawned(Entity);
-        let a = world.spawn().insert_bundle(("abc", 123)).id();
-        world.spawn().insert_bundle(("abc", 123));
+        let a = world.spawn().insert_bundle((W("abc"), W(123))).id();
+        world.spawn().insert_bundle((W("abc"), W(123)));
         world.insert_resource(false);
         world.insert_resource(Despawned(a));
 
         world.entity_mut(a).despawn();
 
         fn validate_removed(
-            removed_i32: RemovedComponents<i32>,
+            removed_i32: RemovedComponents<W<i32>>,
             despawned: Res<Despawned>,
             mut ran: ResMut<bool>,
         ) {
@@ -385,13 +388,13 @@ mod tests {
     fn world_collections_system() {
         let mut world = World::default();
         world.insert_resource(false);
-        world.spawn().insert_bundle((42, true));
+        world.spawn().insert_bundle((W(42), W(true)));
         fn sys(
             archetypes: &Archetypes,
             components: &Components,
             entities: &Entities,
             bundles: &Bundles,
-            query: Query<Entity, With<i32>>,
+            query: Query<Entity, With<W<i32>>>,
             mut modified: ResMut<bool>,
         ) {
             assert_eq!(query.iter().count(), 1, "entity exists");
@@ -400,7 +403,7 @@ mod tests {
                 let archetype = archetypes.get(location.archetype_id).unwrap();
                 let archetype_components = archetype.components().collect::<Vec<_>>();
                 let bundle_id = bundles
-                    .get_id(std::any::TypeId::of::<(i32, bool)>())
+                    .get_id(std::any::TypeId::of::<(W<i32>, W<bool>)>())
                     .expect("Bundle used to spawn entity should exist");
                 let bundle_info = bundles.get(bundle_id).unwrap();
                 let mut bundle_components = bundle_info.components().to_vec();
diff --git a/crates/bevy_ecs/src/world/mod.rs b/crates/bevy_ecs/src/world/mod.rs
index 08153467ff70c..b6dc494920b82 100644
--- a/crates/bevy_ecs/src/world/mod.rs
+++ b/crates/bevy_ecs/src/world/mod.rs
@@ -137,28 +137,6 @@ impl World {
         WorldCell::new(self)
     }
 
-    /// Registers a new component using the given [ComponentDescriptor]. Components do not need to
-    /// be manually registered. This just provides a way to override default configuration.
-    /// Attempting to register a component with a type that has already been used by [World]
-    /// will result in an error.
-    ///
-    /// The default component storage type can be overridden like this:
-    ///
-    /// ```
-    /// use bevy_ecs::{
-    ///     component::{Component, ComponentDescriptor, StorageType},
-    ///     world::World,
-    /// };
-    ///
-    /// #[derive(Component)]
-    /// struct Position {
-    ///   x: f32,
-    ///   y: f32,
-    /// }
-    ///
-    /// let mut world = World::new();
-    /// world.register_component(ComponentDescriptor::new::<Position>(StorageType::SparseSet)).unwrap();
-    /// ```
     pub fn register_component(
         &mut self,
         descriptor: ComponentDescriptor,
@@ -751,17 +729,21 @@ impl World {
     /// worked out to share an ID space (which doesn't happen by default).
     ///
     /// ```
-    /// use bevy_ecs::{entity::Entity, world::World};
+    /// use bevy_ecs::{entity::Entity, world::World, component::Component};
+    /// #[derive(Component)]
+    /// struct A(&'static str);
+    /// #[derive(Component, PartialEq, Debug)]
+    /// struct B(f32);
     ///
     /// let mut world = World::new();
     /// let e0 = world.spawn().id();
     /// let e1 = world.spawn().id();
     /// world.insert_or_spawn_batch(vec![
-    ///   (e0, ("a", 0.0)), // the first entity
-    ///   (e1, ("b", 1.0)), // the second entity
+    ///   (e0, (A("a"), B(0.0))), // the first entity
+    ///   (e1, (A("b"), B(1.0))), // the second entity
     /// ]);
     ///
-    /// assert_eq!(world.get::<f64>(e0), Some(&0.0));
+    /// assert_eq!(world.get::<B>(e0), Some(&B(0.0)));
     /// ```
     pub fn insert_or_spawn_batch<I, B>(&mut self, iter: I) -> Result<(), Vec<Entity>>
     where
diff --git a/crates/bevy_macro_utils/src/attrs.rs b/crates/bevy_macro_utils/src/attrs.rs
index a2f2746ca4fd9..08760bfb7b8f4 100644
--- a/crates/bevy_macro_utils/src/attrs.rs
+++ b/crates/bevy_macro_utils/src/attrs.rs
@@ -35,7 +35,7 @@ pub fn parse_attrs(ast: &DeriveInput, attr_name: Symbol) -> syn::Result<Vec<syn:
     Ok(list)
 }
 
-pub fn get_lit_str<'a>(attr_name: Symbol, lit: &'a syn::Lit) -> syn::Result<&'a syn::LitStr> {
+pub fn get_lit_str(attr_name: Symbol, lit: &syn::Lit) -> syn::Result<&syn::LitStr> {
     if let syn::Lit::Str(lit) = lit {
         Ok(lit)
     } else {

From 8648736a913d126a36d0efff387a2bdd089d0eb4 Mon Sep 17 00:00:00 2001
From: TheRawMeatball <therawmeatball@gmail.com>
Date: Thu, 23 Sep 2021 21:30:27 +0300
Subject: [PATCH 11/22] Fix benches

---
 benches/benches/bevy_ecs/commands.rs  |   4 +-
 benches/benches/bevy_ecs/stages.rs    |   3 +-
 benches/benches/bevy_ecs/world_get.rs | 184 +++++++++++++++-----------
 3 files changed, 108 insertions(+), 83 deletions(-)

diff --git a/benches/benches/bevy_ecs/commands.rs b/benches/benches/bevy_ecs/commands.rs
index 959273688e8f1..c4d974238dadb 100644
--- a/benches/benches/bevy_ecs/commands.rs
+++ b/benches/benches/bevy_ecs/commands.rs
@@ -99,7 +99,7 @@ fn insert_commands(criterion: &mut Criterion) {
         let mut world = World::default();
         let mut command_queue = CommandQueue::default();
         let mut entities = Vec::new();
-        for i in 0..entity_count {
+        for _ in 0..entity_count {
             entities.push(world.spawn().id());
         }
 
@@ -118,7 +118,7 @@ fn insert_commands(criterion: &mut Criterion) {
         let mut world = World::default();
         let mut command_queue = CommandQueue::default();
         let mut entities = Vec::new();
-        for i in 0..entity_count {
+        for _ in 0..entity_count {
             entities.push(world.spawn().id());
         }
 
diff --git a/benches/benches/bevy_ecs/stages.rs b/benches/benches/bevy_ecs/stages.rs
index 8e5159eac2fa0..8e572acff131c 100644
--- a/benches/benches/bevy_ecs/stages.rs
+++ b/benches/benches/bevy_ecs/stages.rs
@@ -1,6 +1,7 @@
 use bevy::ecs::{
+    component::Component,
     schedule::{Stage, SystemStage},
-    system::{IntoSystem, Query},
+    system::Query,
     world::World,
 };
 use criterion::{criterion_group, criterion_main, Criterion};
diff --git a/benches/benches/bevy_ecs/world_get.rs b/benches/benches/bevy_ecs/world_get.rs
index 9d3308524b45a..fc943ede4742f 100644
--- a/benches/benches/bevy_ecs/world_get.rs
+++ b/benches/benches/bevy_ecs/world_get.rs
@@ -1,8 +1,4 @@
-use bevy::ecs::{
-    component::{ComponentDescriptor, StorageType},
-    entity::Entity,
-    world::World,
-};
+use bevy::ecs::{component::Component, entity::Entity, world::World};
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
 
 criterion_group!(
@@ -15,17 +11,18 @@ criterion_group!(
 );
 criterion_main!(benches);
 
-#[derive(Component)]
-struct A(f32);
+#[derive(Component, Default)]
+#[component(storage = "Table")]
+struct Table(f32);
+#[derive(Component, Default)]
+#[component(storage = "SparseSet")]
+struct Sparse(f32);
 
 const RANGE: std::ops::Range<u32> = 5..6;
 
-fn setup(entity_count: u32, storage: StorageType) -> World {
+fn setup<T: Component + Default>(entity_count: u32) -> World {
     let mut world = World::default();
-    world
-        .register_component(ComponentDescriptor::new::<A>(storage))
-        .unwrap();
-    world.spawn_batch((0..entity_count).map(|_| (A(0.0),)));
+    world.spawn_batch((0..entity_count).map(|_| (T::default(),)));
     world
 }
 
@@ -36,7 +33,7 @@ fn world_entity(criterion: &mut Criterion) {
 
     for entity_count in RANGE.map(|i| i * 10_000) {
         group.bench_function(format!("{}_entities", entity_count), |bencher| {
-            let world = setup(entity_count, StorageType::Table);
+            let world = setup::<Table>(entity_count);
 
             bencher.iter(|| {
                 for i in 0..entity_count {
@@ -56,21 +53,26 @@ fn world_get(criterion: &mut Criterion) {
     group.measurement_time(std::time::Duration::from_secs(4));
 
     for entity_count in RANGE.map(|i| i * 10_000) {
-        for storage in [StorageType::Table, StorageType::SparseSet] {
-            group.bench_function(
-                format!("{}_entities_{:?}", entity_count, storage),
-                |bencher| {
-                    let world = setup(entity_count, storage);
-
-                    bencher.iter(|| {
-                        for i in 0..entity_count {
-                            let entity = Entity::new(i);
-                            assert!(world.get::<A>(entity).is_some());
-                        }
-                    });
-                },
-            );
-        }
+        group.bench_function(format!("{}_entities_table", entity_count), |bencher| {
+            let world = setup::<Table>(entity_count);
+
+            bencher.iter(|| {
+                for i in 0..entity_count {
+                    let entity = Entity::new(i);
+                    assert!(world.get::<Table>(entity).is_some());
+                }
+            });
+        });
+        group.bench_function(format!("{}_entities_sparse", entity_count), |bencher| {
+            let world = setup::<Sparse>(entity_count);
+
+            bencher.iter(|| {
+                for i in 0..entity_count {
+                    let entity = Entity::new(i);
+                    assert!(world.get::<Sparse>(entity).is_some());
+                }
+            });
+        });
     }
 
     group.finish();
@@ -82,22 +84,28 @@ fn world_query_get(criterion: &mut Criterion) {
     group.measurement_time(std::time::Duration::from_secs(4));
 
     for entity_count in RANGE.map(|i| i * 10_000) {
-        for storage in [StorageType::Table, StorageType::SparseSet] {
-            group.bench_function(
-                format!("{}_entities_{:?}", entity_count, storage),
-                |bencher| {
-                    let mut world = setup(entity_count, storage);
-                    let mut query = world.query::<&A>();
-
-                    bencher.iter(|| {
-                        for i in 0..entity_count {
-                            let entity = Entity::new(i);
-                            assert!(query.get(&world, entity).is_ok());
-                        }
-                    });
-                },
-            );
-        }
+        group.bench_function(format!("{}_entities_table", entity_count), |bencher| {
+            let mut world = setup::<Table>(entity_count);
+            let mut query = world.query::<&Table>();
+
+            bencher.iter(|| {
+                for i in 0..entity_count {
+                    let entity = Entity::new(i);
+                    assert!(query.get(&world, entity).is_ok());
+                }
+            });
+        });
+        group.bench_function(format!("{}_entities_sparse", entity_count), |bencher| {
+            let mut world = setup::<Sparse>(entity_count);
+            let mut query = world.query::<&Sparse>();
+
+            bencher.iter(|| {
+                for i in 0..entity_count {
+                    let entity = Entity::new(i);
+                    assert!(query.get(&world, entity).is_ok());
+                }
+            });
+        });
     }
 
     group.finish();
@@ -109,24 +117,32 @@ fn world_query_iter(criterion: &mut Criterion) {
     group.measurement_time(std::time::Duration::from_secs(4));
 
     for entity_count in RANGE.map(|i| i * 10_000) {
-        for storage in [StorageType::Table, StorageType::SparseSet] {
-            group.bench_function(
-                format!("{}_entities_{:?}", entity_count, storage),
-                |bencher| {
-                    let mut world = setup(entity_count, storage);
-                    let mut query = world.query::<&A>();
-
-                    bencher.iter(|| {
-                        let mut count = 0;
-                        for comp in query.iter(&world) {
-                            black_box(comp);
-                            count += 1;
-                        }
-                        assert_eq!(black_box(count), entity_count);
-                    });
-                },
-            );
-        }
+        group.bench_function(format!("{}_entities_table", entity_count), |bencher| {
+            let mut world = setup::<Table>(entity_count);
+            let mut query = world.query::<&Table>();
+
+            bencher.iter(|| {
+                let mut count = 0;
+                for comp in query.iter(&world) {
+                    black_box(comp);
+                    count += 1;
+                }
+                assert_eq!(black_box(count), entity_count);
+            });
+        });
+        group.bench_function(format!("{}_entities_sparse", entity_count), |bencher| {
+            let mut world = setup::<Sparse>(entity_count);
+            let mut query = world.query::<&Sparse>();
+
+            bencher.iter(|| {
+                let mut count = 0;
+                for comp in query.iter(&world) {
+                    black_box(comp);
+                    count += 1;
+                }
+                assert_eq!(black_box(count), entity_count);
+            });
+        });
     }
 
     group.finish();
@@ -138,24 +154,32 @@ fn world_query_for_each(criterion: &mut Criterion) {
     group.measurement_time(std::time::Duration::from_secs(4));
 
     for entity_count in RANGE.map(|i| i * 10_000) {
-        for storage in [StorageType::Table, StorageType::SparseSet] {
-            group.bench_function(
-                format!("{}_entities_{:?}", entity_count, storage),
-                |bencher| {
-                    let mut world = setup(entity_count, storage);
-                    let mut query = world.query::<&A>();
-
-                    bencher.iter(|| {
-                        let mut count = 0;
-                        query.for_each(&world, |comp| {
-                            black_box(comp);
-                            count += 1;
-                        });
-                        assert_eq!(black_box(count), entity_count);
-                    });
-                },
-            );
-        }
+        group.bench_function(format!("{}_entities_table", entity_count), |bencher| {
+            let mut world = setup::<Table>(entity_count);
+            let mut query = world.query::<&Table>();
+
+            bencher.iter(|| {
+                let mut count = 0;
+                query.for_each(&world, |comp| {
+                    black_box(comp);
+                    count += 1;
+                });
+                assert_eq!(black_box(count), entity_count);
+            });
+        });
+        group.bench_function(format!("{}_entities_sparse", entity_count), |bencher| {
+            let mut world = setup::<Sparse>(entity_count);
+            let mut query = world.query::<&Sparse>();
+
+            bencher.iter(|| {
+                let mut count = 0;
+                query.for_each(&world, |comp| {
+                    black_box(comp);
+                    count += 1;
+                });
+                assert_eq!(black_box(count), entity_count);
+            });
+        });
     }
 
     group.finish();

From a26e10dc36acb0754057be3d8660d6dbf8307215 Mon Sep 17 00:00:00 2001
From: TheRawMeatball <therawmeatball@gmail.com>
Date: Fri, 24 Sep 2021 16:47:54 +0300
Subject: [PATCH 12/22] Fix registration issue with sparse set components

---
 crates/bevy_ecs/README.md          | 5 -----
 crates/bevy_ecs/src/component.rs   | 4 +---
 crates/bevy_ecs/src/lib.rs         | 9 +--------
 crates/bevy_ecs/src/query/fetch.rs | 3 +++
 4 files changed, 5 insertions(+), 16 deletions(-)

diff --git a/crates/bevy_ecs/README.md b/crates/bevy_ecs/README.md
index 478b23b915a1f..da3d6267dd827 100644
--- a/crates/bevy_ecs/README.md
+++ b/crates/bevy_ecs/README.md
@@ -195,11 +195,6 @@ Components can be stored in:
 
 Component storage types are configurable, and they default to table storage if the storage is not manually defined. The [`component_storage.rs`](examples/component_storage.rs) example shows how to configure the storage type for a component.
 
-```rust
-// store Position components in Sparse Sets
-world.register_component(ComponentDescriptor::new::<Position>(StorageType::SparseSet));
-```
-
 ### Component Bundles
 
 Define sets of Components that should be added together.
diff --git a/crates/bevy_ecs/src/component.rs b/crates/bevy_ecs/src/component.rs
index 596c58b2ef8e4..7bf764dc46547 100644
--- a/crates/bevy_ecs/src/component.rs
+++ b/crates/bevy_ecs/src/component.rs
@@ -5,7 +5,6 @@ pub use bevy_ecs_macros::Component;
 use std::{
     alloc::Layout,
     any::{Any, TypeId},
-    collections::hash_map::Entry,
 };
 use thiserror::Error;
 
@@ -248,8 +247,7 @@ impl Components {
     ) -> Result<ComponentId, ComponentsError> {
         let index = self.components.len();
         if let Some(type_id) = descriptor.type_id {
-            let index_entry = self.indices.entry(type_id);
-            if let Entry::Occupied(_) = index_entry {
+            if self.indices.contains_key(&type_id) {
                 return Err(ComponentsError::ComponentAlreadyExists {
                     type_id,
                     name: descriptor.name,
diff --git a/crates/bevy_ecs/src/lib.rs b/crates/bevy_ecs/src/lib.rs
index aa6aba1347e8f..5e9a4bb49a1d4 100644
--- a/crates/bevy_ecs/src/lib.rs
+++ b/crates/bevy_ecs/src/lib.rs
@@ -547,11 +547,6 @@ mod tests {
     fn query_optional_component_sparse_no_match() {
         let mut world = World::new();
 
-        //TODO: fix component registration in queries so this isn't needed.
-        world
-            .register_component(bevy_ecs::component::ComponentDescriptor::new::<SparseStored>())
-            .unwrap();
-
         let e = world
             .spawn()
             .insert_bundle((TableStored("abc"), A(123)))
@@ -1343,9 +1338,7 @@ mod tests {
         let (dropck1, dropped1) = DropCk::new_pair();
         let (dropck2, dropped2) = DropCk::new_pair();
         let mut world = World::default();
-        // world
-        //     .register_component(ComponentDescriptor::new::<DropCk>(StorageType::SparseSet))
-        //     .unwrap();
+
         world.spawn().insert(dropck1).insert(dropck2);
         assert_eq!(dropped1.load(Ordering::Relaxed), 1);
         assert_eq!(dropped2.load(Ordering::Relaxed), 0);
diff --git a/crates/bevy_ecs/src/query/fetch.rs b/crates/bevy_ecs/src/query/fetch.rs
index c0b9b09a4b1f7..254745562800f 100644
--- a/crates/bevy_ecs/src/query/fetch.rs
+++ b/crates/bevy_ecs/src/query/fetch.rs
@@ -233,6 +233,9 @@ pub struct ReadState<T> {
 unsafe impl<T: Component> FetchState for ReadState<T> {
     fn init(world: &mut World) -> Self {
         let component_info = world.components.get_or_insert_info::<T>();
+        if T::Storage::STORAGE_TYPE == StorageType::SparseSet {
+            world.storages.sparse_sets.get_or_insert(component_info);
+        };
         ReadState {
             component_id: component_info.id(),
             marker: PhantomData,

From 87f7511e03bba1adc023d66370fe049fe93d88d8 Mon Sep 17 00:00:00 2001
From: TheRawMeatball <therawmeatball@gmail.com>
Date: Fri, 24 Sep 2021 16:53:23 +0300
Subject: [PATCH 13/22] Uncomment tests

---
 crates/bevy_ecs/src/query/mod.rs | 48 ++++++++++++++------------------
 1 file changed, 21 insertions(+), 27 deletions(-)

diff --git a/crates/bevy_ecs/src/query/mod.rs b/crates/bevy_ecs/src/query/mod.rs
index 66b6ac36d4ad5..dcc2416940cc2 100644
--- a/crates/bevy_ecs/src/query/mod.rs
+++ b/crates/bevy_ecs/src/query/mod.rs
@@ -9,22 +9,20 @@ pub use fetch::*;
 pub use filter::*;
 pub use iter::*;
 pub use state::*;
-/*
-TODO: Adjust tests to use derive comopnent, and reenable them.
 
 #[cfg(test)]
 mod tests {
-    use crate::{
-        self as bevy_ecs,
-        component::{Component, ComponentDescriptor, StorageType},
-        world::World,
-    };
+    use crate::{self as bevy_ecs, component::Component, world::World};
 
     #[derive(Component, Debug, Eq, PartialEq)]
     struct A(usize);
     #[derive(Component, Debug, Eq, PartialEq)]
     struct B(usize);
 
+    #[derive(Component, Debug, Eq, PartialEq)]
+    #[component(storage = "SparseSet")]
+    struct Sparse(usize);
+
     #[test]
     fn query() {
         let mut world = World::new();
@@ -142,13 +140,10 @@ mod tests {
     #[test]
     fn query_iter_combinations_sparse() {
         let mut world = World::new();
-        world
-            .register_component(ComponentDescriptor::new::<A>(StorageType::SparseSet))
-            .unwrap();
 
-        world.spawn_batch((1..=4).map(|i| (A(i),)));
+        world.spawn_batch((1..=4).map(|i| (Sparse(i),)));
 
-        let mut query = world.query::<&mut A>();
+        let mut query = world.query::<&mut Sparse>();
         let mut combinations = query.iter_combinations_mut(&mut world);
         while let Some([mut a, mut b, mut c]) = combinations.fetch_next() {
             a.0 += 10;
@@ -156,15 +151,15 @@ mod tests {
             c.0 += 1000;
         }
 
-        let mut query = world.query::<&A>();
-        let values: Vec<[&A; 3]> = query.iter_combinations(&world).collect();
+        let mut query = world.query::<&Sparse>();
+        let values: Vec<[&Sparse; 3]> = query.iter_combinations(&world).collect();
         assert_eq!(
             values,
             vec![
-                [&A(31), &A(212), &A(1203)],
-                [&A(31), &A(212), &A(3004)],
-                [&A(31), &A(1203), &A(3004)],
-                [&A(212), &A(1203), &A(3004)]
+                [&Sparse(31), &Sparse(212), &Sparse(1203)],
+                [&Sparse(31), &Sparse(212), &Sparse(3004)],
+                [&Sparse(31), &Sparse(1203), &Sparse(3004)],
+                [&Sparse(212), &Sparse(1203), &Sparse(3004)]
             ]
         );
     }
@@ -172,17 +167,17 @@ mod tests {
     #[test]
     fn multi_storage_query() {
         let mut world = World::new();
-        world
-            .register_component(ComponentDescriptor::new::<A>(StorageType::SparseSet))
-            .unwrap();
 
-        world.spawn().insert_bundle((A(1), B(2)));
-        world.spawn().insert_bundle((A(2),));
+        world.spawn().insert_bundle((Sparse(1), B(2)));
+        world.spawn().insert_bundle((Sparse(2),));
 
-        let values = world.query::<&A>().iter(&world).collect::<Vec<&A>>();
-        assert_eq!(values, vec![&A(1), &A(2)]);
+        let values = world
+            .query::<&Sparse>()
+            .iter(&world)
+            .collect::<Vec<&Sparse>>();
+        assert_eq!(values, vec![&Sparse(1), &Sparse(2)]);
 
-        for (_a, mut b) in world.query::<(&A, &mut B)>().iter_mut(&mut world) {
+        for (_a, mut b) in world.query::<(&Sparse, &mut B)>().iter_mut(&mut world) {
             b.0 = 3;
         }
 
@@ -190,4 +185,3 @@ mod tests {
         assert_eq!(values, vec![&B(3)]);
     }
 }
-*/

From d5723e1a72ced25a9cda61399c77121968b686f8 Mon Sep 17 00:00:00 2001
From: TheRawMeatball <therawmeatball@gmail.com>
Date: Fri, 1 Oct 2021 08:01:37 +0300
Subject: [PATCH 14/22] Add safety line to ComponentDescriptor

---
 crates/bevy_ecs/src/component.rs | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/crates/bevy_ecs/src/component.rs b/crates/bevy_ecs/src/component.rs
index 7bf764dc46547..a64ed7cd11e6c 100644
--- a/crates/bevy_ecs/src/component.rs
+++ b/crates/bevy_ecs/src/component.rs
@@ -163,6 +163,8 @@ impl SparseSetIndex for ComponentId {
 #[derive(Debug)]
 pub struct ComponentDescriptor {
     name: String,
+    // SAFETY: This must remain private. It must match the statically known StorageType of the
+    // associated rust component type if one exists.
     storage_type: StorageType,
     // SAFETY: This must remain private. It must only be set to "true" if this component is
     // actually Send + Sync

From 4ffef8e6e821b54f559f0d175783ce0cbc5bfdca Mon Sep 17 00:00:00 2001
From: TheRawMeatball <therawmeatball@gmail.com>
Date: Fri, 1 Oct 2021 08:04:36 +0300
Subject: [PATCH 15/22] Add DropCkSparse

---
 crates/bevy_ecs/src/lib.rs | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/crates/bevy_ecs/src/lib.rs b/crates/bevy_ecs/src/lib.rs
index 09e8b7941b52b..00660160584e2 100644
--- a/crates/bevy_ecs/src/lib.rs
+++ b/crates/bevy_ecs/src/lib.rs
@@ -82,6 +82,10 @@ mod tests {
         }
     }
 
+    #[derive(Component, Clone, Debug)]
+    #[component(storage = "SparseSet")]
+    struct DropCkSparse(DropCk);
+
     #[derive(Component, Copy, Clone, PartialEq, Eq, Debug)]
     #[component(storage = "Table")]
     struct TableStored(&'static str);
@@ -1343,7 +1347,10 @@ mod tests {
         let (dropck2, dropped2) = DropCk::new_pair();
         let mut world = World::default();
 
-        world.spawn().insert(dropck1).insert(dropck2);
+        world
+            .spawn()
+            .insert(DropCkSparse(dropck1))
+            .insert(DropCkSparse(dropck2));
         assert_eq!(dropped1.load(Ordering::Relaxed), 1);
         assert_eq!(dropped2.load(Ordering::Relaxed), 0);
         drop(world);

From 7e13713f3cb2322af064137515e980f478dd1c3b Mon Sep 17 00:00:00 2001
From: TheRawMeatball <therawmeatball@gmail.com>
Date: Fri, 1 Oct 2021 08:06:51 +0300
Subject: [PATCH 16/22] Fix broken reference to example with inline code

---
 crates/bevy_ecs/README.md | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/crates/bevy_ecs/README.md b/crates/bevy_ecs/README.md
index da3d6267dd827..8bdb28fa59cd4 100644
--- a/crates/bevy_ecs/README.md
+++ b/crates/bevy_ecs/README.md
@@ -193,7 +193,16 @@ Components can be stored in:
 * **Tables**: Fast and cache friendly iteration, but slower adding and removing of components. This is the default storage type.
 * **Sparse Sets**: Fast adding and removing of components, but slower iteration.
 
-Component storage types are configurable, and they default to table storage if the storage is not manually defined. The [`component_storage.rs`](examples/component_storage.rs) example shows how to configure the storage type for a component.
+Component storage types are configurable, and they default to table storage if the storage is not manually defined.
+
+```rs
+#[derive(Component)]
+struct TableStoredComponent;
+
+#[derive(Component)]
+#[component(storage = "SparseSet")]
+struct SparseStoredComponent;
+```
 
 ### Component Bundles
 

From 102920c3296e65b85222cc551175c3f1e642e65c Mon Sep 17 00:00:00 2001
From: TheRawMeatball <therawmeatball@gmail.com>
Date: Fri, 1 Oct 2021 08:07:36 +0300
Subject: [PATCH 17/22] Flatten small snippet

---
 crates/bevy_sprite/src/lib.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/crates/bevy_sprite/src/lib.rs b/crates/bevy_sprite/src/lib.rs
index 04c43db1ac5d3..f41df39675577 100644
--- a/crates/bevy_sprite/src/lib.rs
+++ b/crates/bevy_sprite/src/lib.rs
@@ -88,8 +88,7 @@ impl Plugin for SpritePlugin {
                 frustum_culling::atlas_frustum_culling_system,
             );
         }
-        let world = &mut app.world;
-        let world_cell = world.cell();
+        let world_cell = app.world.cell();
         let mut render_graph = world_cell.get_resource_mut::<RenderGraph>().unwrap();
         let mut pipelines = world_cell
             .get_resource_mut::<Assets<PipelineDescriptor>>()

From 5f418c461d499e9410ed2e4dff4d9940257a86a9 Mon Sep 17 00:00:00 2001
From: TheRawMeatball <therawmeatball@gmail.com>
Date: Fri, 1 Oct 2021 08:09:19 +0300
Subject: [PATCH 18/22] Adress safety doc TODO

---
 crates/bevy_ecs/macros/src/lib.rs | 3 +--
 crates/bevy_ecs/src/bundle.rs     | 3 +--
 2 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/crates/bevy_ecs/macros/src/lib.rs b/crates/bevy_ecs/macros/src/lib.rs
index 8e79901f1b5db..c6c3cbb65e2c5 100644
--- a/crates/bevy_ecs/macros/src/lib.rs
+++ b/crates/bevy_ecs/macros/src/lib.rs
@@ -157,8 +157,7 @@ pub fn derive_bundle(input: TokenStream) -> TokenStream {
     let struct_name = &ast.ident;
 
     TokenStream::from(quote! {
-        // TODO: TypeInfo no longer exists, verify safety again
-        /// SAFE: TypeInfo is returned in field-definition-order. [from_components] and [get_components] use field-definition-order
+        /// SAFE: ComponentId is returned in field-definition-order. [from_components] and [get_components] use field-definition-order
         unsafe impl #impl_generics #ecs_path::bundle::Bundle for #struct_name#ty_generics #where_clause {
             const IS_DENSE: bool = true #(&& #is_dense_exprs)*;
 
diff --git a/crates/bevy_ecs/src/bundle.rs b/crates/bevy_ecs/src/bundle.rs
index 9ac603507923e..2404917748e63 100644
--- a/crates/bevy_ecs/src/bundle.rs
+++ b/crates/bevy_ecs/src/bundle.rs
@@ -99,8 +99,7 @@ pub unsafe trait Bundle: Send + Sync + 'static {
 
 macro_rules! tuple_impl {
     ($($name: ident),*) => {
-        // TODO: TypeInfo no longer exists, verify safety again
-        /// SAFE: TypeInfo is returned in tuple-order. [Bundle::from_components] and [Bundle::get_components] use tuple-order
+        /// SAFE: Component is returned in tuple-order. [Bundle::from_components] and [Bundle::get_components] use tuple-order
         unsafe impl<$($name: Component),*> Bundle for ($($name,)*) {
             #[allow(unused_variables)]
             fn component_ids(components: &mut Components) -> Vec<ComponentId> {

From 698512178f805a4acb469716b73849a4b68ff341 Mon Sep 17 00:00:00 2001
From: TheRawMeatball <therawmeatball@gmail.com>
Date: Fri, 1 Oct 2021 08:12:06 +0300
Subject: [PATCH 19/22] Remove Bundle::IS_DENSE

---
 crates/bevy_ecs/macros/src/lib.rs | 12 ------------
 crates/bevy_ecs/src/bundle.rs     |  9 ---------
 2 files changed, 21 deletions(-)

diff --git a/crates/bevy_ecs/macros/src/lib.rs b/crates/bevy_ecs/macros/src/lib.rs
index c6c3cbb65e2c5..29cb9da257c65 100644
--- a/crates/bevy_ecs/macros/src/lib.rs
+++ b/crates/bevy_ecs/macros/src/lib.rs
@@ -115,7 +115,6 @@ pub fn derive_bundle(input: TokenStream) -> TokenStream {
     let mut field_component_ids = Vec::new();
     let mut field_get_components = Vec::new();
     let mut field_from_components = Vec::new();
-    let mut is_dense_exprs = Vec::new();
     for ((field_type, is_bundle), field) in
         field_type.iter().zip(is_bundle.iter()).zip(field.iter())
     {
@@ -129,9 +128,6 @@ pub fn derive_bundle(input: TokenStream) -> TokenStream {
             field_from_components.push(quote! {
                 #field: <#field_type as #ecs_path::bundle::Bundle>::from_components(&mut func),
             });
-            is_dense_exprs.push(quote! {
-                <#field_type as #ecs_path::bundle::Bundle>::IS_DENSE
-            });
         } else {
             field_component_ids.push(quote! {
                 component_ids.push(components.get_or_insert_id::<#field_type>());
@@ -143,12 +139,6 @@ pub fn derive_bundle(input: TokenStream) -> TokenStream {
             field_from_components.push(quote! {
                 #field: func().cast::<#field_type>().read(),
             });
-            is_dense_exprs.push(quote! {
-                match <<#field_type as #ecs_path::component::Component>::Storage as #ecs_path::component::ComponentStorage>::STORAGE_TYPE {
-                    #ecs_path::component::StorageType::Table => true,
-                    #ecs_path::component::StorageType::SparseSet => false,
-                }
-            });
         }
     }
     let field_len = field.len();
@@ -159,8 +149,6 @@ pub fn derive_bundle(input: TokenStream) -> TokenStream {
     TokenStream::from(quote! {
         /// SAFE: ComponentId is returned in field-definition-order. [from_components] and [get_components] use field-definition-order
         unsafe impl #impl_generics #ecs_path::bundle::Bundle for #struct_name#ty_generics #where_clause {
-            const IS_DENSE: bool = true #(&& #is_dense_exprs)*;
-
             fn component_ids(
                 components: &mut #ecs_path::component::Components,
             ) -> Vec<#ecs_path::component::ComponentId> {
diff --git a/crates/bevy_ecs/src/bundle.rs b/crates/bevy_ecs/src/bundle.rs
index 2404917748e63..f12042a99eb95 100644
--- a/crates/bevy_ecs/src/bundle.rs
+++ b/crates/bevy_ecs/src/bundle.rs
@@ -76,8 +76,6 @@ use std::{any::TypeId, collections::HashMap};
 /// - [Bundle::from_components] must call `func` exactly once for each [ComponentId] returned by
 ///   [Bundle::component_ids].
 pub unsafe trait Bundle: Send + Sync + 'static {
-    const IS_DENSE: bool;
-
     /// Gets this [Bundle]'s component ids, in the order of this bundle's Components
     fn component_ids(components: &mut Components) -> Vec<ComponentId>;
 
@@ -106,13 +104,6 @@ macro_rules! tuple_impl {
                 vec![$(components.get_or_insert_id::<$name>()),*]
             }
 
-            const IS_DENSE: bool = true $(&&
-                match <$name::Storage as $crate::component::ComponentStorage>::STORAGE_TYPE {
-                    StorageType::Table => true,
-                    StorageType::SparseSet => false,
-                }
-            )*;
-
             #[allow(unused_variables, unused_mut)]
             #[allow(clippy::unused_unit)]
             unsafe fn from_components(mut func: impl FnMut() -> *mut u8) -> Self {

From 62f856f0fb33f7d6ac37b655e54fb6ecda028bdd Mon Sep 17 00:00:00 2001
From: TheRawMeatball <therawmeatball@gmail.com>
Date: Fri, 1 Oct 2021 08:25:40 +0300
Subject: [PATCH 20/22] use generalized register fn in query initializers

---
 crates/bevy_ecs/src/component.rs    | 17 ++++++++---------
 crates/bevy_ecs/src/query/fetch.rs  | 15 ++++++---------
 crates/bevy_ecs/src/query/filter.rs | 14 +++++++-------
 crates/bevy_ecs/src/world/mod.rs    |  7 +++++++
 4 files changed, 28 insertions(+), 25 deletions(-)

diff --git a/crates/bevy_ecs/src/component.rs b/crates/bevy_ecs/src/component.rs
index a64ed7cd11e6c..90f7aaa99006a 100644
--- a/crates/bevy_ecs/src/component.rs
+++ b/crates/bevy_ecs/src/component.rs
@@ -239,7 +239,11 @@ pub struct Components {
 #[derive(Debug, Error)]
 pub enum ComponentsError {
     #[error("A component of type {name:?} ({type_id:?}) already exists")]
-    ComponentAlreadyExists { type_id: TypeId, name: String },
+    ComponentAlreadyExists {
+        type_id: TypeId,
+        name: String,
+        existing_id: ComponentId,
+    },
 }
 
 impl Components {
@@ -249,10 +253,12 @@ impl Components {
     ) -> Result<ComponentId, ComponentsError> {
         let index = self.components.len();
         if let Some(type_id) = descriptor.type_id {
-            if self.indices.contains_key(&type_id) {
+            let i = self.indices.get(&type_id);
+            if let Some(&index) = i {
                 return Err(ComponentsError::ComponentAlreadyExists {
                     type_id,
                     name: descriptor.name,
+                    existing_id: self.components[index].id,
                 });
             }
             self.indices.insert(type_id, index);
@@ -269,13 +275,6 @@ impl Components {
         unsafe { self.get_or_insert_with(TypeId::of::<T>(), ComponentDescriptor::new::<T>) }
     }
 
-    #[inline]
-    pub fn get_or_insert_info<T: Component>(&mut self) -> &ComponentInfo {
-        let id = self.get_or_insert_id::<T>();
-        // SAFE: component_info with the given `id` initialized above
-        unsafe { self.get_info_unchecked(id) }
-    }
-
     #[inline]
     pub fn len(&self) -> usize {
         self.components.len()
diff --git a/crates/bevy_ecs/src/query/fetch.rs b/crates/bevy_ecs/src/query/fetch.rs
index 254745562800f..bcc32a11b6625 100644
--- a/crates/bevy_ecs/src/query/fetch.rs
+++ b/crates/bevy_ecs/src/query/fetch.rs
@@ -232,12 +232,9 @@ pub struct ReadState<T> {
 // read
 unsafe impl<T: Component> FetchState for ReadState<T> {
     fn init(world: &mut World) -> Self {
-        let component_info = world.components.get_or_insert_info::<T>();
-        if T::Storage::STORAGE_TYPE == StorageType::SparseSet {
-            world.storages.sparse_sets.get_or_insert(component_info);
-        };
+        let component_id = world.register_or_get_id::<T>();
         ReadState {
-            component_id: component_info.id(),
+            component_id,
             marker: PhantomData,
         }
     }
@@ -414,9 +411,9 @@ pub struct WriteState<T> {
 // written
 unsafe impl<T: Component> FetchState for WriteState<T> {
     fn init(world: &mut World) -> Self {
-        let component_info = world.components.get_or_insert_info::<T>();
+        let component_id = world.register_or_get_id::<T>();
         WriteState {
-            component_id: component_info.id(),
+            component_id,
             marker: PhantomData,
         }
     }
@@ -746,9 +743,9 @@ pub struct ChangeTrackersState<T> {
 // read
 unsafe impl<T: Component> FetchState for ChangeTrackersState<T> {
     fn init(world: &mut World) -> Self {
-        let component_info = world.components.get_or_insert_info::<T>();
+        let component_id = world.register_or_get_id::<T>();
         Self {
-            component_id: component_info.id(),
+            component_id,
             marker: PhantomData,
         }
     }
diff --git a/crates/bevy_ecs/src/query/filter.rs b/crates/bevy_ecs/src/query/filter.rs
index eefb2ce81d3de..f408da71bb121 100644
--- a/crates/bevy_ecs/src/query/filter.rs
+++ b/crates/bevy_ecs/src/query/filter.rs
@@ -88,9 +88,9 @@ pub struct WithState<T> {
 // SAFETY: no component access or archetype component access
 unsafe impl<T: Component> FetchState for WithState<T> {
     fn init(world: &mut World) -> Self {
-        let component_info = world.components.get_or_insert_info::<T>();
+        let component_id = world.register_or_get_id::<T>();
         Self {
-            component_id: component_info.id(),
+            component_id,
             marker: PhantomData,
         }
     }
@@ -207,9 +207,9 @@ pub struct WithoutState<T> {
 // SAFETY: no component access or archetype component access
 unsafe impl<T: Component> FetchState for WithoutState<T> {
     fn init(world: &mut World) -> Self {
-        let component_info = world.components.get_or_insert_info::<T>();
+        let component_id = world.register_or_get_id::<T>();
         Self {
-            component_id: component_info.id(),
+            component_id,
             marker: PhantomData,
         }
     }
@@ -472,10 +472,10 @@ macro_rules! impl_tick_filter {
         // 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 {
-                let component_info = world.components.get_or_insert_info::<T>();
+                let component_id = world.register_or_get_id::<T>();
                 Self {
-                    component_id: component_info.id(),
-                    storage_type: component_info.storage_type(),
+                    component_id,
+                    storage_type: T::Storage::STORAGE_TYPE,
                     marker: PhantomData,
                 }
             }
diff --git a/crates/bevy_ecs/src/world/mod.rs b/crates/bevy_ecs/src/world/mod.rs
index c039f6bb1b812..ed8bbc4149665 100644
--- a/crates/bevy_ecs/src/world/mod.rs
+++ b/crates/bevy_ecs/src/world/mod.rs
@@ -190,6 +190,13 @@ impl World {
         Ok(component_id)
     }
 
+    pub(crate) fn register_or_get_id<T: Component>(&mut self) -> ComponentId {
+        self.register_component(ComponentDescriptor::new::<T>())
+            .unwrap_or_else(|e| match e {
+                ComponentsError::ComponentAlreadyExists { existing_id, .. } => existing_id,
+            })
+    }
+
     /// Retrieves an [EntityRef] that exposes read-only operations for the given `entity`.
     /// This will panic if the `entity` does not exist. Use [World::get_entity] if you want
     /// to check for entity existence instead of implicitly panic-ing.

From ecb71ac33c873fa22de4b31f9ba1c19c96bb6cd0 Mon Sep 17 00:00:00 2001
From: Carter Anderson <mcanders1@gmail.com>
Date: Fri, 1 Oct 2021 16:35:49 -0700
Subject: [PATCH 21/22] Centralize and simplify component init

---
 crates/bevy_app/src/app.rs                 | 13 -----
 crates/bevy_ecs/macros/src/lib.rs          |  5 +-
 crates/bevy_ecs/src/bundle.rs              | 14 ++---
 crates/bevy_ecs/src/component.rs           | 68 +++++++---------------
 crates/bevy_ecs/src/lib.rs                 | 16 ++---
 crates/bevy_ecs/src/query/fetch.rs         |  6 +-
 crates/bevy_ecs/src/query/filter.rs        |  9 ++-
 crates/bevy_ecs/src/storage/table.rs       |  4 +-
 crates/bevy_ecs/src/system/system_param.rs |  2 +-
 crates/bevy_ecs/src/world/entity_ref.rs    |  6 +-
 crates/bevy_ecs/src/world/mod.rs           | 40 ++++---------
 crates/bevy_ecs/src/world/spawn_batch.rs   |  4 +-
 12 files changed, 64 insertions(+), 123 deletions(-)

diff --git a/crates/bevy_app/src/app.rs b/crates/bevy_app/src/app.rs
index d22cef4979e97..4887bb5917367 100644
--- a/crates/bevy_app/src/app.rs
+++ b/crates/bevy_app/src/app.rs
@@ -1,6 +1,5 @@
 use crate::{CoreStage, Events, Plugin, PluginGroup, PluginGroupBuilder, StartupStage};
 use bevy_ecs::{
-    component::ComponentDescriptor,
     prelude::{FromWorld, IntoExclusiveSystem},
     schedule::{
         IntoSystemDescriptor, RunOnce, Schedule, Stage, StageLabel, State, StateData, SystemSet,
@@ -812,18 +811,6 @@ impl App {
         self
     }
 
-    /// Registers a new component using the given [ComponentDescriptor].
-    ///
-    /// Components do not need to be manually registered. This just provides a way to
-    /// override default configuration. Attempting to register a component with a type
-    /// that has already been used by [World] will result in an error.
-    ///
-    /// See [World::register_component]
-    pub fn register_component(&mut self, descriptor: ComponentDescriptor) -> &mut Self {
-        self.world.register_component(descriptor).unwrap();
-        self
-    }
-
     /// Adds the type `T` to the type registry resource.
     #[cfg(feature = "bevy_reflect")]
     pub fn register_type<T: bevy_reflect::GetTypeRegistration>(&mut self) -> &mut Self {
diff --git a/crates/bevy_ecs/macros/src/lib.rs b/crates/bevy_ecs/macros/src/lib.rs
index 29cb9da257c65..e508c7ac2c6e5 100644
--- a/crates/bevy_ecs/macros/src/lib.rs
+++ b/crates/bevy_ecs/macros/src/lib.rs
@@ -120,7 +120,7 @@ pub fn derive_bundle(input: TokenStream) -> TokenStream {
     {
         if *is_bundle {
             field_component_ids.push(quote! {
-                component_ids.extend(<#field_type as #ecs_path::bundle::Bundle>::component_ids(components));
+                component_ids.extend(<#field_type as #ecs_path::bundle::Bundle>::component_ids(components, storages));
             });
             field_get_components.push(quote! {
                 self.#field.get_components(&mut func);
@@ -130,7 +130,7 @@ pub fn derive_bundle(input: TokenStream) -> TokenStream {
             });
         } else {
             field_component_ids.push(quote! {
-                component_ids.push(components.get_or_insert_id::<#field_type>());
+                component_ids.push(components.init_component::<#field_type>(storages));
             });
             field_get_components.push(quote! {
                 func((&mut self.#field as *mut #field_type).cast::<u8>());
@@ -151,6 +151,7 @@ pub fn derive_bundle(input: TokenStream) -> TokenStream {
         unsafe impl #impl_generics #ecs_path::bundle::Bundle for #struct_name#ty_generics #where_clause {
             fn component_ids(
                 components: &mut #ecs_path::component::Components,
+                storages: &mut #ecs_path::storage::Storages,
             ) -> Vec<#ecs_path::component::ComponentId> {
                 let mut component_ids = Vec::with_capacity(#field_len);
                 #(#field_component_ids)*
diff --git a/crates/bevy_ecs/src/bundle.rs b/crates/bevy_ecs/src/bundle.rs
index f12042a99eb95..463a0483cf5e4 100644
--- a/crates/bevy_ecs/src/bundle.rs
+++ b/crates/bevy_ecs/src/bundle.rs
@@ -77,7 +77,7 @@ use std::{any::TypeId, collections::HashMap};
 ///   [Bundle::component_ids].
 pub unsafe trait Bundle: Send + Sync + 'static {
     /// Gets this [Bundle]'s component ids, in the order of this bundle's Components
-    fn component_ids(components: &mut Components) -> Vec<ComponentId>;
+    fn component_ids(components: &mut Components, storages: &mut Storages) -> Vec<ComponentId>;
 
     /// Calls `func`, which should return data for each component in the bundle, in the order of
     /// this bundle's Components
@@ -100,8 +100,8 @@ macro_rules! tuple_impl {
         /// SAFE: Component is returned in tuple-order. [Bundle::from_components] and [Bundle::get_components] use tuple-order
         unsafe impl<$($name: Component),*> Bundle for ($($name,)*) {
             #[allow(unused_variables)]
-            fn component_ids(components: &mut Components) -> Vec<ComponentId> {
-                vec![$(components.get_or_insert_id::<$name>()),*]
+            fn component_ids(components: &mut Components, storages: &mut Storages) -> Vec<ComponentId> {
+                vec![$(components.init_component::<$name>(storages)),*]
             }
 
             #[allow(unused_variables, unused_mut)]
@@ -328,10 +328,7 @@ impl BundleInfo {
                 let component_info = unsafe { components.get_info_unchecked(component_id) };
                 match component_info.storage_type() {
                     StorageType::Table => new_table_components.push(component_id),
-                    StorageType::SparseSet => {
-                        storages.sparse_sets.get_or_insert(component_info);
-                        new_sparse_set_components.push(component_id)
-                    }
+                    StorageType::SparseSet => new_sparse_set_components.push(component_id),
                 }
             }
         }
@@ -595,10 +592,11 @@ impl Bundles {
     pub(crate) fn init_info<'a, T: Bundle>(
         &'a mut self,
         components: &mut Components,
+        storages: &mut Storages,
     ) -> &'a BundleInfo {
         let bundle_infos = &mut self.bundle_infos;
         let id = self.bundle_ids.entry(TypeId::of::<T>()).or_insert_with(|| {
-            let component_ids = T::component_ids(components);
+            let component_ids = T::component_ids(components, storages);
             let id = BundleId(bundle_infos.len());
             // SAFE: T::component_id ensures info was created
             let bundle_info = unsafe {
diff --git a/crates/bevy_ecs/src/component.rs b/crates/bevy_ecs/src/component.rs
index 90f7aaa99006a..5ece927418713 100644
--- a/crates/bevy_ecs/src/component.rs
+++ b/crates/bevy_ecs/src/component.rs
@@ -1,6 +1,9 @@
 //! Types for declaring and storing [`Component`]s.
 
-use crate::{storage::SparseSetIndex, system::Resource};
+use crate::{
+    storage::{SparseSetIndex, Storages},
+    system::Resource,
+};
 pub use bevy_ecs_macros::Component;
 use std::{
     alloc::Layout,
@@ -247,32 +250,21 @@ pub enum ComponentsError {
 }
 
 impl Components {
-    pub(crate) fn add(
-        &mut self,
-        descriptor: ComponentDescriptor,
-    ) -> Result<ComponentId, ComponentsError> {
-        let index = self.components.len();
-        if let Some(type_id) = descriptor.type_id {
-            let i = self.indices.get(&type_id);
-            if let Some(&index) = i {
-                return Err(ComponentsError::ComponentAlreadyExists {
-                    type_id,
-                    name: descriptor.name,
-                    existing_id: self.components[index].id,
-                });
-            }
-            self.indices.insert(type_id, index);
-        }
-        self.components
-            .push(ComponentInfo::new(ComponentId(index), descriptor));
-
-        Ok(ComponentId(index))
-    }
-
     #[inline]
-    pub fn get_or_insert_id<T: Component>(&mut self) -> ComponentId {
-        // SAFE: The [`ComponentDescriptor`] matches the [`TypeId`]
-        unsafe { self.get_or_insert_with(TypeId::of::<T>(), ComponentDescriptor::new::<T>) }
+    pub fn init_component<T: Component>(&mut self, storages: &mut Storages) -> ComponentId {
+        let type_id = TypeId::of::<T>();
+        let components = &mut self.components;
+        let index = self.indices.entry(type_id).or_insert_with(|| {
+            let index = components.len();
+            let descriptor = ComponentDescriptor::new::<T>();
+            let info = ComponentInfo::new(ComponentId(index), descriptor);
+            if T::Storage::STORAGE_TYPE == StorageType::SparseSet {
+                storages.sparse_sets.get_or_insert(&info);
+            }
+            components.push(info);
+            index
+        });
+        ComponentId(*index)
     }
 
     #[inline]
@@ -312,7 +304,7 @@ impl Components {
     }
 
     #[inline]
-    pub fn get_or_insert_resource_id<T: Resource>(&mut self) -> ComponentId {
+    pub fn init_resource<T: Resource>(&mut self) -> ComponentId {
         // SAFE: The [`ComponentDescriptor`] matches the [`TypeId`]
         unsafe {
             self.get_or_insert_resource_with(TypeId::of::<T>(), || {
@@ -322,7 +314,7 @@ impl Components {
     }
 
     #[inline]
-    pub fn get_or_insert_non_send_resource_id<T: Any>(&mut self) -> ComponentId {
+    pub fn init_non_send<T: Any>(&mut self) -> ComponentId {
         // SAFE: The [`ComponentDescriptor`] matches the [`TypeId`]
         unsafe {
             self.get_or_insert_resource_with(TypeId::of::<T>(), || {
@@ -350,26 +342,6 @@ impl Components {
 
         ComponentId(*index)
     }
-
-    /// # Safety
-    ///
-    /// The [`ComponentDescriptor`] must match the [`TypeId`]
-    #[inline]
-    pub(crate) unsafe fn get_or_insert_with(
-        &mut self,
-        type_id: TypeId,
-        func: impl FnOnce() -> ComponentDescriptor,
-    ) -> ComponentId {
-        let components = &mut self.components;
-        let index = self.indices.entry(type_id).or_insert_with(|| {
-            let descriptor = func();
-            let index = components.len();
-            components.push(ComponentInfo::new(ComponentId(index), descriptor));
-            index
-        });
-
-        ComponentId(*index)
-    }
 }
 
 #[derive(Clone, Debug)]
diff --git a/crates/bevy_ecs/src/lib.rs b/crates/bevy_ecs/src/lib.rs
index 00660160584e2..6fb347a2a7e8f 100644
--- a/crates/bevy_ecs/src/lib.rs
+++ b/crates/bevy_ecs/src/lib.rs
@@ -130,10 +130,10 @@ mod tests {
         }
 
         assert_eq!(
-            <Foo as Bundle>::component_ids(world.components_mut()),
+            <Foo as Bundle>::component_ids(&mut world.components, &mut world.storages),
             vec![
-                world.components_mut().get_or_insert_id::<TableStored>(),
-                world.components_mut().get_or_insert_id::<SparseStored>(),
+                world.init_component::<TableStored>(),
+                world.init_component::<SparseStored>(),
             ]
         );
 
@@ -178,12 +178,12 @@ mod tests {
         }
 
         assert_eq!(
-            <Nested as Bundle>::component_ids(world.components_mut()),
+            <Nested as Bundle>::component_ids(&mut world.components, &mut world.storages),
             vec![
-                world.components_mut().get_or_insert_id::<A>(),
-                world.components_mut().get_or_insert_id::<TableStored>(),
-                world.components_mut().get_or_insert_id::<SparseStored>(),
-                world.components_mut().get_or_insert_id::<B>(),
+                world.init_component::<A>(),
+                world.init_component::<TableStored>(),
+                world.init_component::<SparseStored>(),
+                world.init_component::<B>(),
             ]
         );
 
diff --git a/crates/bevy_ecs/src/query/fetch.rs b/crates/bevy_ecs/src/query/fetch.rs
index bcc32a11b6625..9572a797f1f90 100644
--- a/crates/bevy_ecs/src/query/fetch.rs
+++ b/crates/bevy_ecs/src/query/fetch.rs
@@ -232,7 +232,7 @@ pub struct ReadState<T> {
 // read
 unsafe impl<T: Component> FetchState for ReadState<T> {
     fn init(world: &mut World) -> Self {
-        let component_id = world.register_or_get_id::<T>();
+        let component_id = world.init_component::<T>();
         ReadState {
             component_id,
             marker: PhantomData,
@@ -411,7 +411,7 @@ pub struct WriteState<T> {
 // written
 unsafe impl<T: Component> FetchState for WriteState<T> {
     fn init(world: &mut World) -> Self {
-        let component_id = world.register_or_get_id::<T>();
+        let component_id = world.init_component::<T>();
         WriteState {
             component_id,
             marker: PhantomData,
@@ -743,7 +743,7 @@ pub struct ChangeTrackersState<T> {
 // read
 unsafe impl<T: Component> FetchState for ChangeTrackersState<T> {
     fn init(world: &mut World) -> Self {
-        let component_id = world.register_or_get_id::<T>();
+        let component_id = world.init_component::<T>();
         Self {
             component_id,
             marker: PhantomData,
diff --git a/crates/bevy_ecs/src/query/filter.rs b/crates/bevy_ecs/src/query/filter.rs
index f408da71bb121..a1c9e13c4cff5 100644
--- a/crates/bevy_ecs/src/query/filter.rs
+++ b/crates/bevy_ecs/src/query/filter.rs
@@ -88,7 +88,7 @@ pub struct WithState<T> {
 // SAFETY: no component access or archetype component access
 unsafe impl<T: Component> FetchState for WithState<T> {
     fn init(world: &mut World) -> Self {
-        let component_id = world.register_or_get_id::<T>();
+        let component_id = world.init_component::<T>();
         Self {
             component_id,
             marker: PhantomData,
@@ -207,7 +207,7 @@ pub struct WithoutState<T> {
 // SAFETY: no component access or archetype component access
 unsafe impl<T: Component> FetchState for WithoutState<T> {
     fn init(world: &mut World) -> Self {
-        let component_id = world.register_or_get_id::<T>();
+        let component_id = world.init_component::<T>();
         Self {
             component_id,
             marker: PhantomData,
@@ -446,7 +446,7 @@ macro_rules! impl_tick_filter {
 
         $(#[$fetch_meta])*
         pub struct $fetch_name<T> {
-            storage_type: StorageType,
+            storage_type: StorageType, // TODO: remove this?
             table_ticks: *const UnsafeCell<ComponentTicks>,
             entity_table_rows: *const usize,
             marker: PhantomData<T>,
@@ -472,9 +472,8 @@ macro_rules! impl_tick_filter {
         // 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 {
-                let component_id = world.register_or_get_id::<T>();
                 Self {
-                    component_id,
+                    component_id: world.init_component::<T>(),
                     storage_type: T::Storage::STORAGE_TYPE,
                     marker: PhantomData,
                 }
diff --git a/crates/bevy_ecs/src/storage/table.rs b/crates/bevy_ecs/src/storage/table.rs
index 489fa164a01ff..3f9a0b38b4f38 100644
--- a/crates/bevy_ecs/src/storage/table.rs
+++ b/crates/bevy_ecs/src/storage/table.rs
@@ -524,6 +524,7 @@ impl IndexMut<TableId> for Tables {
 mod tests {
     use crate as bevy_ecs;
     use crate::component::Component;
+    use crate::storage::Storages;
     use crate::{component::Components, entity::Entity, storage::Table};
     #[derive(Component)]
     struct W<T>(T);
@@ -531,7 +532,8 @@ mod tests {
     #[test]
     fn table() {
         let mut components = Components::default();
-        let component_id = components.get_or_insert_id::<W<usize>>();
+        let mut storages = Storages::default();
+        let component_id = components.init_component::<W<usize>>(&mut storages);
         let columns = &[component_id];
         let mut table = Table::with_capacity(0, columns.len());
         table.add_column(components.get_info(component_id).unwrap());
diff --git a/crates/bevy_ecs/src/system/system_param.rs b/crates/bevy_ecs/src/system/system_param.rs
index 0e606191f9d74..f9f5f60794e38 100644
--- a/crates/bevy_ecs/src/system/system_param.rs
+++ b/crates/bevy_ecs/src/system/system_param.rs
@@ -673,7 +673,7 @@ unsafe impl<T: Component> SystemParamState for RemovedComponentsState<T> {
 
     fn init(world: &mut World, _system_meta: &mut SystemMeta, _config: Self::Config) -> Self {
         Self {
-            component_id: world.components.get_or_insert_id::<T>(),
+            component_id: world.init_component::<T>(),
             marker: PhantomData,
         }
     }
diff --git a/crates/bevy_ecs/src/world/entity_ref.rs b/crates/bevy_ecs/src/world/entity_ref.rs
index c2bae02ca01da..fdaa68bfc8b2e 100644
--- a/crates/bevy_ecs/src/world/entity_ref.rs
+++ b/crates/bevy_ecs/src/world/entity_ref.rs
@@ -194,7 +194,7 @@ impl<'w> EntityMut<'w> {
         let bundle_info = self
             .world
             .bundles
-            .init_info::<T>(&mut self.world.components);
+            .init_info::<T>(&mut self.world.components, &mut self.world.storages);
         let mut bundle_inserter = bundle_info.get_bundle_inserter(
             &mut self.world.entities,
             &mut self.world.archetypes,
@@ -219,7 +219,7 @@ impl<'w> EntityMut<'w> {
         let entities = &mut self.world.entities;
         let removed_components = &mut self.world.removed_components;
 
-        let bundle_info = self.world.bundles.init_info::<T>(components);
+        let bundle_info = self.world.bundles.init_info::<T>(components, storages);
         let old_location = self.location;
         let new_archetype_id = unsafe {
             remove_bundle_from_archetype(
@@ -341,7 +341,7 @@ impl<'w> EntityMut<'w> {
         let entities = &mut self.world.entities;
         let removed_components = &mut self.world.removed_components;
 
-        let bundle_info = self.world.bundles.init_info::<T>(components);
+        let bundle_info = self.world.bundles.init_info::<T>(components, storages);
         let old_location = self.location;
         let new_archetype_id = unsafe {
             remove_bundle_from_archetype(
diff --git a/crates/bevy_ecs/src/world/mod.rs b/crates/bevy_ecs/src/world/mod.rs
index ed8bbc4149665..3f04fc36211ac 100644
--- a/crates/bevy_ecs/src/world/mod.rs
+++ b/crates/bevy_ecs/src/world/mod.rs
@@ -11,10 +11,7 @@ use crate::{
     archetype::{ArchetypeComponentId, ArchetypeComponentInfo, ArchetypeId, Archetypes},
     bundle::{Bundle, BundleInserter, BundleSpawner, Bundles},
     change_detection::Ticks,
-    component::{
-        Component, ComponentDescriptor, ComponentId, ComponentTicks, Components, ComponentsError,
-        StorageType,
-    },
+    component::{Component, ComponentId, ComponentTicks, Components, StorageType},
     entity::{AllocAtWithoutReplacement, Entities, Entity},
     query::{FilterFetch, QueryState, WorldQuery},
     storage::{Column, SparseSet, Storages},
@@ -174,27 +171,8 @@ impl World {
         WorldCell::new(self)
     }
 
-    pub fn register_component(
-        &mut self,
-        descriptor: ComponentDescriptor,
-    ) -> Result<ComponentId, ComponentsError> {
-        let storage_type = descriptor.storage_type();
-        let component_id = self.components.add(descriptor)?;
-        // ensure sparse set is created for SparseSet components
-        if storage_type == StorageType::SparseSet {
-            // SAFE: just created
-            let info = unsafe { self.components.get_info_unchecked(component_id) };
-            self.storages.sparse_sets.get_or_insert(info);
-        }
-
-        Ok(component_id)
-    }
-
-    pub(crate) fn register_or_get_id<T: Component>(&mut self) -> ComponentId {
-        self.register_component(ComponentDescriptor::new::<T>())
-            .unwrap_or_else(|e| match e {
-                ComponentsError::ComponentAlreadyExists { existing_id, .. } => existing_id,
-            })
+    pub fn init_component<T: Component>(&mut self) -> ComponentId {
+        self.components.init_component::<T>(&mut self.storages)
     }
 
     /// Retrieves an [EntityRef] that exposes read-only operations for the given `entity`.
@@ -614,7 +592,7 @@ impl World {
     /// Resources are "unique" data of a given type.
     #[inline]
     pub fn insert_resource<T: Resource>(&mut self, value: T) {
-        let component_id = self.components.get_or_insert_resource_id::<T>();
+        let component_id = self.components.init_resource::<T>();
         // SAFE: component_id just initialized and corresponds to resource of type T
         unsafe { self.insert_resource_with_id(component_id, value) };
     }
@@ -624,7 +602,7 @@ impl World {
     #[inline]
     pub fn insert_non_send<T: 'static>(&mut self, value: T) {
         self.validate_non_send_access::<T>();
-        let component_id = self.components.get_or_insert_non_send_resource_id::<T>();
+        let component_id = self.components.init_non_send::<T>();
         // SAFE: component_id just initialized and corresponds to resource of type T
         unsafe { self.insert_resource_with_id(component_id, value) };
     }
@@ -820,7 +798,9 @@ impl World {
         let iter = iter.into_iter();
         let change_tick = *self.change_tick.get_mut();
 
-        let bundle_info = self.bundles.init_info::<B>(&mut self.components);
+        let bundle_info = self
+            .bundles
+            .init_info::<B>(&mut self.components, &mut self.storages);
         enum SpawnOrInsert<'a, 'b> {
             Spawn(BundleSpawner<'a, 'b>),
             Insert(BundleInserter<'a, 'b>, ArchetypeId),
@@ -1066,14 +1046,14 @@ impl World {
     }
 
     pub(crate) fn initialize_resource<T: Resource>(&mut self) -> ComponentId {
-        let component_id = self.components.get_or_insert_resource_id::<T>();
+        let component_id = self.components.init_resource::<T>();
         // SAFE: resource initialized above
         unsafe { self.initialize_resource_internal(component_id) };
         component_id
     }
 
     pub(crate) fn initialize_non_send_resource<T: 'static>(&mut self) -> ComponentId {
-        let component_id = self.components.get_or_insert_non_send_resource_id::<T>();
+        let component_id = self.components.init_non_send::<T>();
         // SAFE: resource initialized above
         unsafe { self.initialize_resource_internal(component_id) };
         component_id
diff --git a/crates/bevy_ecs/src/world/spawn_batch.rs b/crates/bevy_ecs/src/world/spawn_batch.rs
index 6f84557684633..8ca0bc8d75068 100644
--- a/crates/bevy_ecs/src/world/spawn_batch.rs
+++ b/crates/bevy_ecs/src/world/spawn_batch.rs
@@ -27,7 +27,9 @@ where
         let (lower, upper) = iter.size_hint();
         let length = upper.unwrap_or(lower);
 
-        let bundle_info = world.bundles.init_info::<I::Item>(&mut world.components);
+        let bundle_info = world
+            .bundles
+            .init_info::<I::Item>(&mut world.components, &mut world.storages);
         world.entities.reserve(length as u32);
         let mut spawner = bundle_info.get_bundle_spawner(
             &mut world.entities,

From 3d26878762c59a27386757857e0034c2577663d3 Mon Sep 17 00:00:00 2001
From: Carter Anderson <mcanders1@gmail.com>
Date: Fri, 1 Oct 2021 16:38:42 -0700
Subject: [PATCH 22/22] Remove unnecessary storage_type field

---
 crates/bevy_ecs/src/query/filter.rs | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/crates/bevy_ecs/src/query/filter.rs b/crates/bevy_ecs/src/query/filter.rs
index a1c9e13c4cff5..bbd8ec567a985 100644
--- a/crates/bevy_ecs/src/query/filter.rs
+++ b/crates/bevy_ecs/src/query/filter.rs
@@ -446,7 +446,6 @@ macro_rules! impl_tick_filter {
 
         $(#[$fetch_meta])*
         pub struct $fetch_name<T> {
-            storage_type: StorageType, // TODO: remove this?
             table_ticks: *const UnsafeCell<ComponentTicks>,
             entity_table_rows: *const usize,
             marker: PhantomData<T>,
@@ -459,7 +458,6 @@ macro_rules! impl_tick_filter {
         $(#[$state_meta])*
         pub struct $state_name<T> {
             component_id: ComponentId,
-            storage_type: StorageType,
             marker: PhantomData<T>,
         }
 
@@ -474,7 +472,6 @@ macro_rules! impl_tick_filter {
             fn init(world: &mut World) -> Self {
                 Self {
                     component_id: world.init_component::<T>(),
-                    storage_type: T::Storage::STORAGE_TYPE,
                     marker: PhantomData,
                 }
             }
@@ -514,7 +511,6 @@ macro_rules! impl_tick_filter {
 
             unsafe fn init(world: &World, state: &Self::State, last_change_tick: u32, change_tick: u32) -> Self {
                 let mut value = Self {
-                    storage_type: state.storage_type,
                     table_ticks: ptr::null::<UnsafeCell<ComponentTicks>>(),
                     entities: ptr::null::<Entity>(),
                     entity_table_rows: ptr::null::<usize>(),
@@ -546,7 +542,7 @@ macro_rules! impl_tick_filter {
             }
 
             unsafe fn set_archetype(&mut self, state: &Self::State, archetype: &Archetype, tables: &Tables) {
-                match state.storage_type {
+                match T::Storage::STORAGE_TYPE {
                     StorageType::Table => {
                         self.entity_table_rows = archetype.entity_table_rows().as_ptr();
                         let table = &tables[archetype.table_id()];
@@ -563,7 +559,7 @@ macro_rules! impl_tick_filter {
             }
 
             unsafe fn archetype_fetch(&mut self, archetype_index: usize) -> bool {
-                match self.storage_type {
+                match T::Storage::STORAGE_TYPE {
                     StorageType::Table => {
                         let table_row = *self.entity_table_rows.add(archetype_index);
                         $is_detected(&*(&*self.table_ticks.add(table_row)).get(), self.last_change_tick, self.change_tick)