refactor(engine-ecs): store soles as components

4 files changed, 142 insertions, 194 deletions

diff --git a/engine-ecs-macros/src/lib.rs b/engine-ecs-macros/src/lib.rs
index a304706..106d350 100644
--- a/engine-ecs-macros/src/lib.rs
+++ b/engine-ecs-macros/src/lib.rs
@@ -6,7 +6,6 @@ use quote::{format_ident, quote, ToTokens};
 use syn::spanned::Spanned;
 use syn::{
     parse,
-    Attribute,
     Generics,
     Ident,
     Item,
@@ -148,6 +147,17 @@ pub fn component_derive(input: TokenStream) -> TokenStream
             #where_clause
             {
             }
+
+            impl #ecs_path::component::IntoParts for #item_ident
+            {
+                fn into_parts(self) -> #ecs_path::component::Parts
+                {
+                    #ecs_path::component::Parts::builder()
+                        .name(self.name())
+                        .type_reflection(<Self as Component>::type_reflection())
+                        .build(Self::id(), self)
+                }
+            }
         }
     }
     .into()
@@ -156,50 +166,118 @@ pub fn component_derive(input: TokenStream) -> TokenStream
 /// Generates a `Sole` implementation.
 ///
 /// # Panics
-/// Will panic if not attributed to a type item or if parsing the user crate's
-/// `Cargo.toml` file fails.
-#[proc_macro_derive(Sole, attributes(sole))]
+/// Will panic if:
+/// - Not attributed to a type item
+/// - The attributed-to type item is generic
+/// - If parsing the user crate's `Cargo.toml` file fails.
+#[proc_macro_derive(Sole)]
 pub fn sole_derive(input: TokenStream) -> TokenStream
 {
     let item: TypeItem = parse::<Item>(input).unwrap().try_into().unwrap();
 
     let item_ident = item.ident();
 
-    let sole_attr = item.attribute::<SoleAttribute>("sole").unwrap_or_default();
+    let ecs_path = find_engine_ecs_crate_path().unwrap_or_else(|| syn_path!(ecs));
 
-    let drop_last = sole_attr.drop_last;
+    assert!(
+        item.generics().params.is_empty(),
+        "Generic types are not supported as sole components"
+    );
 
-    let (impl_generics, type_generics, where_clause) = item.generics().split_for_impl();
+    let id_var_ident = format_ident!("{}_ID", item_ident.to_string().to_uppercase());
 
-    let ecs_path = find_engine_ecs_crate_path().unwrap_or_else(|| syn_path!(ecs));
+    let id_var = quote! {
+        static #id_var_ident: LazyLock<Uid> = LazyLock::new(|| {
+            Uid::new_unique()
+        });
+    };
+
+    let mod_ident = format_ident!(
+        "__ecs_priv_sole_impl_{}",
+        item_ident.to_string().to_lowercase()
+    );
 
     quote! {
-        impl #impl_generics #ecs_path::sole::Sole for #item_ident #type_generics
-        #where_clause
-        {
-            fn drop_last(&self) -> bool
-            {
-                #drop_last
-            }
+        mod #mod_ident {
+            use ::std::any::{Any, TypeId};
+            use ::std::sync::{LazyLock, Mutex};
+
+            use #ecs_path::sole::Sole;
+            use #ecs_path::uid::Uid;
+            use #ecs_path::system::Input as SystemInput;
+
+            use super::*;
+
+            #id_var
 
-            fn as_any_mut(&mut self) -> &mut dyn std::any::Any
+            impl Sole for #item_ident
             {
-                self
+                fn id() -> Uid
+                {
+                    *#id_var_ident
+                }
+
+                fn type_reflection() -> Option<&'static #ecs_path::reflection::Type>
+                {
+                    struct SpecializationTarget<T>(std::marker::PhantomData<T>);
+
+                    trait HasReflection
+                    {
+                        fn type_reflection(&self)
+                            -> Option<&'static #ecs_path::reflection::Type>;
+                    }
+
+                    trait NoReflection
+                    {
+                        fn type_reflection(&self)
+                            -> Option<&'static #ecs_path::reflection::Type>;
+                    }
+
+                    impl<T> NoReflection for &SpecializationTarget<T>
+                    {
+                        fn type_reflection(&self)
+                            -> Option<&'static #ecs_path::reflection::Type>
+                        {
+                            None
+                        }
+                    }
+
+                    impl<T> HasReflection for SpecializationTarget<T>
+                    where
+                        T: #ecs_path::reflection::Reflection
+                    {
+                        fn type_reflection(&self)
+                            -> Option<&'static #ecs_path::reflection::Type>
+                        {
+                            Some(T::type_reflection())
+                        }
+                    }
+
+                    (&SpecializationTarget::<Self>(std::marker::PhantomData))
+                        .type_reflection()
+                }
+
+                fn name(&self) -> &'static str
+                {
+                    std::any::type_name::<Self>()
+                }
             }
 
-            fn as_any(&self) -> &dyn std::any::Any
+            impl #ecs_path::component::IntoParts for #item_ident
             {
-                self
+                fn into_parts(self) -> #ecs_path::component::Parts
+                {
+                    #ecs_path::component::Parts::builder()
+                        .name(self.name())
+                        .type_reflection(<Self as Sole>::type_reflection())
+                        .build(Self::id(), self)
+                }
             }
         }
     }
     .into()
 }
 
-trait FromAttribute: Sized
-{
-    fn from_attribute(attribute: &Attribute) -> Result<Self, syn::Error>;
-}
 
 enum TypeItem
 {
@@ -219,27 +297,6 @@ impl TypeItem
         }
     }
 
-    fn attribute<Attr: FromAttribute>(&self, attr_ident: &str) -> Option<Attr>
-    {
-        let item_attrs = match &self {
-            Self::Struct(struct_item) => &struct_item.attrs,
-            &Self::Enum(enum_item) => &enum_item.attrs,
-            &Self::Union(union_item) => &union_item.attrs,
-        };
-
-        let mut attr: Option<&Attribute> = None;
-
-        for item_attr in item_attrs {
-            assert!(attr.is_none(), "Expected only one {attr_ident} attribute");
-
-            if item_attr.path().get_ident()? == attr_ident {
-                attr = Some(item_attr);
-            }
-        }
-
-        Some(Attr::from_attribute(attr?).unwrap())
-    }
-
     fn generics(&self) -> &Generics
     {
         match self {
@@ -280,36 +337,6 @@ impl ToTokens for TypeItem
     }
 }
 
-#[derive(Debug, Default)]
-struct SoleAttribute
-{
-    drop_last: bool,
-}
-
-impl FromAttribute for SoleAttribute
-{
-    fn from_attribute(attribute: &Attribute) -> Result<Self, syn::Error>
-    {
-        let mut drop_last = false;
-
-        attribute.parse_nested_meta(|meta| {
-            if meta
-                .path
-                .get_ident()
-                .is_some_and(|flag| flag == "drop_last")
-            {
-                drop_last = true;
-
-                return Ok(());
-            }
-
-            Err(meta.error("Unrecognized token"))
-        })?;
-
-        Ok(Self { drop_last })
-    }
-}
-
 fn find_engine_ecs_crate_path() -> Option<Path>
 {
     let cargo_manifest_dir = FsPathBuf::from(std::env::var("CARGO_MANIFEST_DIR").ok()?);
diff --git a/engine-ecs/src/component.rs b/engine-ecs/src/component.rs
index 157d79c..25ec101 100644
--- a/engine-ecs/src/component.rs
+++ b/engine-ecs/src/component.rs
@@ -1,4 +1,4 @@
-use std::any::{type_name, Any};
+use std::any::Any;
 use std::fmt::Debug;
 use std::ops::{Deref, DerefMut};
 
@@ -24,7 +24,7 @@ pub mod local;
 
 pub(crate) mod storage;
 
-pub trait Component: SystemInput + Any
+pub trait Component: SystemInput + Any + IntoParts
 {
     /// Returns the ID of this component.
     fn id() -> Uid
@@ -286,19 +286,6 @@ pub trait IntoParts
     fn into_parts(self) -> Parts;
 }
 
-impl<ComponentT> IntoParts for ComponentT
-where
-    ComponentT: Component,
-{
-    fn into_parts(self) -> Parts
-    {
-        Parts::builder()
-            .name(type_name::<Self>())
-            .type_reflection(Self::type_reflection())
-            .build(Self::id(), self)
-    }
-}
-
 /// The parts of a component.
 #[derive(Debug)]
 #[non_exhaustive]
diff --git a/engine-ecs/src/lib.rs b/engine-ecs/src/lib.rs
index 1c157e3..25866ca 100644
--- a/engine-ecs/src/lib.rs
+++ b/engine-ecs/src/lib.rs
@@ -1,14 +1,10 @@
 #![deny(clippy::all, clippy::pedantic)]
 
-use std::any::{type_name, Any, TypeId};
+use std::any::Any;
 use std::fmt::Debug;
 use std::hint::cold_path;
-use std::mem::ManuallyDrop;
 use std::rc::Rc;
 use std::sync::atomic::{AtomicBool, Ordering};
-use std::sync::Arc;
-
-use hashbrown::HashMap;
 
 use crate::actions::Action;
 use crate::component::storage::archetype::EntityComponent as ArchetypeEntityComponent;
@@ -156,7 +152,7 @@ impl World
         entity_decl.create(self);
     }
 
-    /// Adds a globally shared singleton value.
+    /// Adds a singleton.
     ///
     /// # Errors
     /// Returns `Err` if this [`Sole`] has already been added.
@@ -164,7 +160,9 @@ impl World
     where
         SoleT: Sole,
     {
-        self.data.sole_storage.insert(sole)
+        self.create_ent(SoleT::id(), [sole.into_parts()]);
+
+        Ok(())
     }
 
     pub fn register_observer<'this, SystemImpl, ObserverT>(
@@ -253,7 +251,9 @@ impl World
 
     pub fn get_sole<SoleT: Sole>(&self) -> Option<Single<'_, SoleT>>
     {
-        Some(Single::new(self.data.sole_storage.get::<SoleT>()?))
+        let ent = self.get_entity(SoleT::id())?;
+
+        Some(Single::new(ent.get_with_id_mut(SoleT::id())?))
     }
 
     pub fn event_submitter(&self) -> EventSubmitter<'_>
@@ -701,7 +701,6 @@ pub enum StepResult
 struct WorldData
 {
     component_storage: ComponentStorage,
-    sole_storage: SoleStorage,
     action_queue: Rc<ActionQueue>,
     new_events: Lock<NewEvents>,
 }
@@ -765,73 +764,3 @@ impl ActionQueue
 #[error("Sole {0} already exists")]
 pub struct SoleAlreadyExistsError(pub &'static str);
 
-#[derive(Debug)]
-struct StoredSole
-{
-    sole: Arc<Lock<Box<dyn Sole>>>,
-    drop_last: bool,
-}
-
-#[derive(Debug, Default)]
-struct SoleStorage
-{
-    storage: HashMap<TypeId, ManuallyDrop<StoredSole>>,
-}
-
-impl SoleStorage
-{
-    fn get<SoleT: Sole>(&self) -> Option<&Arc<Lock<Box<dyn Sole>>>>
-    {
-        self.storage
-            .get(&TypeId::of::<SoleT>())
-            .map(|sole| &sole.sole)
-    }
-
-    fn insert<SoleT: Sole>(&mut self, sole: SoleT) -> Result<(), SoleAlreadyExistsError>
-    {
-        let sole_type_id = TypeId::of::<SoleT>();
-
-        if self.storage.contains_key(&sole_type_id) {
-            return Err(SoleAlreadyExistsError(type_name::<SoleT>()));
-        }
-
-        let drop_last = sole.drop_last();
-
-        // TODO: Reconsider this maybe?
-        #[allow(clippy::arc_with_non_send_sync)]
-        self.storage.insert(
-            sole_type_id,
-            ManuallyDrop::new(StoredSole {
-                sole: Arc::new(Lock::new(Box::new(sole), type_name::<SoleT>())),
-                drop_last,
-            }),
-        );
-
-        Ok(())
-    }
-}
-
-impl Drop for SoleStorage
-{
-    fn drop(&mut self)
-    {
-        let mut soles_to_drop_last = Vec::new();
-
-        for sole in self.storage.values_mut() {
-            if sole.drop_last {
-                soles_to_drop_last.push(sole);
-                continue;
-            }
-
-            unsafe {
-                ManuallyDrop::drop(sole);
-            }
-        }
-
-        for sole in &mut soles_to_drop_last {
-            unsafe {
-                ManuallyDrop::drop(sole);
-            }
-        }
-    }
-}
diff --git a/engine-ecs/src/sole.rs b/engine-ecs/src/sole.rs
index 9e27fee..9409bcb 100644
--- a/engine-ecs/src/sole.rs
+++ b/engine-ecs/src/sole.rs
@@ -1,33 +1,43 @@
 use std::any::{type_name, Any};
 use std::fmt::Debug;
-use std::marker::PhantomData;
 use std::ops::{Deref, DerefMut};
-use std::sync::Arc;
 
-use crate::lock::{Lock, WriteGuard};
+use crate::uid::Uid;
+use crate::component::HandleMut as ComponentHandleMut;
+use crate::component::IntoParts as IntoComponentParts;
 use crate::system::{Metadata as SystemMetadata, Param as SystemParam};
 use crate::World;
 
 /// A type which has a single instance and is shared globally.
-pub trait Sole: Any
+pub trait Sole: Any + IntoComponentParts
 {
-    fn drop_last(&self) -> bool;
+    fn id() -> Uid
+    where
+        Self: Sized;
 
-    fn as_any_mut(&mut self) -> &mut dyn Any;
+    fn type_reflection() -> Option<&'static crate::reflection::Type>
+    where
+        Self: Sized;
 
-    fn as_any(&self) -> &dyn Any;
+    /// Returns the name of this component.
+    fn name(&self) -> &'static str;
 }
 
 impl dyn Sole
 {
     pub fn downcast_mut<Real: 'static>(&mut self) -> Option<&mut Real>
     {
-        self.as_any_mut().downcast_mut()
+        (self as &mut dyn Any).downcast_mut()
     }
 
     pub fn downcast_ref<Real: 'static>(&self) -> Option<&Real>
     {
-        self.as_any().downcast_ref()
+        (self as &dyn Any).downcast_ref()
+    }
+
+    pub fn is<Other: 'static>(&self) -> bool
+    {
+        (self as &dyn Any).is::<Other>()
     }
 }
 
@@ -43,25 +53,17 @@ impl Debug for dyn Sole
 #[derive(Debug)]
 pub struct Single<'world, SoleT: Sole>
 {
-    sole: WriteGuard<'world, Box<dyn Sole>>,
-    _ph: PhantomData<SoleT>,
+    sole: ComponentHandleMut<'world, SoleT>,
 }
 
+
 impl<'world, SoleT> Single<'world, SoleT>
 where
     SoleT: Sole,
 {
-    pub(crate) fn new(sole: &'world Arc<Lock<Box<dyn Sole>>>) -> Self
+    pub(crate) fn new(sole: ComponentHandleMut<'world, SoleT>) -> Self
     {
-        Self {
-            sole: sole.write_nonblock().unwrap_or_else(|_| {
-                panic!(
-                    "Failed to aquire read-write lock to single component {}",
-                    type_name::<SoleT>()
-                )
-            }),
-            _ph: PhantomData,
-        }
+        Self { sole }
     }
 }
 
@@ -73,9 +75,12 @@ where
 
     fn new(world: &'world World, _system_metadata: &SystemMetadata) -> Self
     {
-        let sole = world.data.sole_storage.get::<SoleT>().unwrap_or_else(|| {
-            panic!("Sole {} was not found in world", type_name::<SoleT>())
-        });
+        let sole = world
+            .get_entity(SoleT::id())
+            .and_then(|ent| ent.get_with_id_mut::<SoleT>(SoleT::id()))
+            .unwrap_or_else(|| {
+                panic!("Sole component {} was not found in world", type_name::<SoleT>())
+            });
 
         Self::new(sole)
     }
@@ -89,7 +94,7 @@ where
 
     fn deref(&self) -> &Self::Target
     {
-        self.sole.downcast_ref().unwrap()
+        &*self.sole
     }
 }
 
@@ -99,6 +104,6 @@ where
 {
     fn deref_mut(&mut self) -> &mut Self::Target
     {
-        self.sole.downcast_mut().unwrap()
+        &mut *self.sole
     }
 }