feat: add binding factories to DI container

10 files changed, 441 insertions, 49 deletions

diff --git a/example/src/main.rs b/example/src/main.rs
index 1f23179..28f29b4 100644
--- a/example/src/main.rs
+++ b/example/src/main.rs
@@ -1,4 +1,8 @@
+use std::rc::Rc;
+
 use syrette::errors::di_container::DIContainerError;
+use syrette::factory;
+use syrette::interfaces::factory::IFactory;
 use syrette::{injectable, DIContainer};
 
 trait IDog
@@ -54,6 +58,32 @@ trait ICow
     fn moo(&self);
 }
 
+struct Cow
+{
+    _moo_cnt: i32,
+}
+
+impl Cow
+{
+    fn new(moo_cnt: i32) -> Self
+    {
+        Self { _moo_cnt: moo_cnt }
+    }
+}
+
+impl ICow for Cow
+{
+    fn moo(&self)
+    {
+        for _ in 0..self._moo_cnt {
+            println!("Moo");
+        }
+    }
+}
+
+#[factory]
+type CowFactory = dyn IFactory<(i32,), dyn ICow>;
+
 trait IHuman
 {
     fn make_pets_make_sounds(&self);
@@ -63,16 +93,18 @@ struct Human
 {
     _dog: Box<dyn IDog>,
     _cat: Box<dyn ICat>,
+    _cow_factory: Rc<CowFactory>,
 }
 
 #[injectable(IHuman)]
 impl Human
 {
-    fn new(dog: Box<dyn IDog>, cat: Box<dyn ICat>) -> Self
+    fn new(dog: Box<dyn IDog>, cat: Box<dyn ICat>, cow_factory: Rc<CowFactory>) -> Self
     {
         Self {
             _dog: dog,
             _cat: cat,
+            _cow_factory: cow_factory,
         }
     }
 }
@@ -88,6 +120,10 @@ impl IHuman for Human
         println!("Hi kitty!");
 
         self._cat.meow();
+
+        let cow: Box<dyn ICow> = (self._cow_factory)(3);
+
+        cow.moo();
     }
 }
 
@@ -101,6 +137,11 @@ fn main() -> error_stack::Result<(), DIContainerError>
     di_container.bind::<dyn ICat>().to::<Cat>();
     di_container.bind::<dyn IHuman>().to::<Human>();
 
+    di_container.bind::<CowFactory>().to_factory(&|moo_cnt| {
+        let cow: Box<dyn ICow> = Box::new(Cow::new(moo_cnt));
+        cow
+    });
+
     let dog = di_container.get::<dyn IDog>()?;
 
     dog.woof();
diff --git a/syrette/src/castable_factory.rs b/syrette/src/castable_factory.rs
new file mode 100644
index 0000000..8713ec4
--- /dev/null
+++ b/syrette/src/castable_factory.rs
@@ -0,0 +1,72 @@
+use crate::interfaces::factory::IFactory;
+use crate::libs::intertrait::CastFrom;
+
+pub trait AnyFactory: CastFrom {}
+
+pub struct CastableFactory<Args, Return>
+where
+    Args: 'static,
+    Return: 'static + ?Sized,
+{
+    _func: &'static dyn Fn<Args, Output = Box<Return>>,
+}
+
+impl<Args, Return> CastableFactory<Args, Return>
+where
+    Args: 'static,
+    Return: 'static + ?Sized,
+{
+    pub fn new(func: &'static dyn Fn<Args, Output = Box<Return>>) -> Self
+    {
+        Self { _func: func }
+    }
+}
+
+impl<Args, Return> IFactory<Args, Return> for CastableFactory<Args, Return>
+where
+    Args: 'static,
+    Return: 'static + ?Sized,
+{
+}
+
+impl<Args, Return> Fn<Args> for CastableFactory<Args, Return>
+where
+    Args: 'static,
+    Return: 'static + ?Sized,
+{
+    extern "rust-call" fn call(&self, args: Args) -> Self::Output
+    {
+        self._func.call(args)
+    }
+}
+
+impl<Args, Return> FnMut<Args> for CastableFactory<Args, Return>
+where
+    Args: 'static,
+    Return: 'static + ?Sized,
+{
+    extern "rust-call" fn call_mut(&mut self, args: Args) -> Self::Output
+    {
+        self.call(args)
+    }
+}
+
+impl<Args, Return> FnOnce<Args> for CastableFactory<Args, Return>
+where
+    Args: 'static,
+    Return: 'static + ?Sized,
+{
+    type Output = Box<Return>;
+
+    extern "rust-call" fn call_once(self, args: Args) -> Self::Output
+    {
+        self.call(args)
+    }
+}
+
+impl<Args, Return> AnyFactory for CastableFactory<Args, Return>
+where
+    Args: 'static,
+    Return: 'static + ?Sized,
+{
+}
diff --git a/syrette/src/di_container.rs b/syrette/src/di_container.rs
index 32d53f2..53c4287 100644
--- a/syrette/src/di_container.rs
+++ b/syrette/src/di_container.rs
@@ -5,23 +5,26 @@ use std::rc::Rc;
 
 use error_stack::{Report, ResultExt};
 
+use crate::castable_factory::CastableFactory;
 use crate::errors::di_container::DIContainerError;
+use crate::interfaces::factory::IFactory;
 use crate::interfaces::injectable::Injectable;
 use crate::libs::intertrait::cast_box::CastBox;
-use crate::provider::{IInjectableTypeProvider, InjectableTypeProvider};
+use crate::libs::intertrait::cast_rc::CastRc;
+use crate::provider::{FactoryProvider, IProvider, InjectableTypeProvider, Providable};
 
-/// Binding builder for `InterfaceTrait` in a [`DIContainer`].
-pub struct BindingBuilder<'a, InterfaceTrait>
+/// Binding builder for type `Interface` inside a [`DIContainer`].
+pub struct BindingBuilder<'a, Interface>
 where
-    InterfaceTrait: 'static + ?Sized,
+    Interface: 'static + ?Sized,
 {
     _di_container: &'a mut DIContainer,
-    _phantom_data: PhantomData<InterfaceTrait>,
+    _phantom_data: PhantomData<Interface>,
 }
 
-impl<'a, InterfaceTrait> BindingBuilder<'a, InterfaceTrait>
+impl<'a, Interface> BindingBuilder<'a, Interface>
 where
-    InterfaceTrait: 'static + ?Sized,
+    Interface: 'static + ?Sized,
 {
     fn new(di_container: &'a mut DIContainer) -> Self
     {
@@ -31,19 +34,39 @@ where
         }
     }
 
-    /// Creates a binding of `InterfaceTrait` to type `Implementation` inside of the
+    /// Creates a binding of type `Interface` to type `Implementation` inside of the
     /// associated [`DIContainer`].
     pub fn to<Implementation>(&mut self)
     where
         Implementation: Injectable,
     {
-        let interface_typeid = TypeId::of::<InterfaceTrait>();
+        let interface_typeid = TypeId::of::<Interface>();
 
         self._di_container._bindings.insert(
             interface_typeid,
             Rc::new(InjectableTypeProvider::<Implementation>::new()),
         );
     }
+
+    /// Creates a binding of factory type `Interface` to a factory inside of the
+    /// associated [`DIContainer`].
+    pub fn to_factory<Args, Return>(
+        &mut self,
+        factory_func: &'static dyn Fn<Args, Output = Box<Return>>,
+    ) where
+        Args: 'static,
+        Return: 'static + ?Sized,
+        Interface: IFactory<Args, Return>,
+    {
+        let interface_typeid = TypeId::of::<Interface>();
+
+        let factory_impl = CastableFactory::new(factory_func);
+
+        self._di_container._bindings.insert(
+            interface_typeid,
+            Rc::new(FactoryProvider::new(Rc::new(factory_impl))),
+        );
+    }
 }
 
 /// Dependency injection container.
@@ -56,7 +79,7 @@ where
 /// ```
 pub struct DIContainer
 {
-    _bindings: HashMap<TypeId, Rc<dyn IInjectableTypeProvider>>,
+    _bindings: HashMap<TypeId, Rc<dyn IProvider>>,
 }
 
 impl<'a> DIContainer
@@ -69,46 +92,95 @@ impl<'a> DIContainer
         }
     }
 
-    /// Returns a new [`BindingBuilder`] for the given interface trait.
-    pub fn bind<InterfaceTrait>(&'a mut self) -> BindingBuilder<InterfaceTrait>
+    /// Returns a new [`BindingBuilder`] for the given interface.
+    pub fn bind<Interface>(&'a mut self) -> BindingBuilder<Interface>
     where
-        InterfaceTrait: 'static + ?Sized,
+        Interface: 'static + ?Sized,
     {
-        BindingBuilder::<InterfaceTrait>::new(self)
+        BindingBuilder::<Interface>::new(self)
     }
 
-    /// Returns the value bound with `InterfaceTrait`.
-    pub fn get<InterfaceTrait>(
-        &self,
-    ) -> error_stack::Result<Box<InterfaceTrait>, DIContainerError>
+    /// Returns a new instance of the type bound with `Interface`.
+    pub fn get<Interface>(&self) -> error_stack::Result<Box<Interface>, DIContainerError>
     where
-        InterfaceTrait: 'static + ?Sized,
+        Interface: 'static + ?Sized,
     {
-        let interface_typeid = TypeId::of::<InterfaceTrait>();
+        let interface_typeid = TypeId::of::<Interface>();
 
-        let interface_name = type_name::<InterfaceTrait>();
+        let interface_name = type_name::<Interface>();
 
         let binding = self._bindings.get(&interface_typeid).ok_or_else(|| {
             Report::new(DIContainerError)
                 .attach_printable(format!("No binding exists for {}", interface_name))
         })?;
 
-        let binding_injectable = binding
+        let binding_providable = binding
             .provide(self)
             .change_context(DIContainerError)
             .attach_printable(format!(
-            "Failed to resolve interface {}",
+            "Failed to resolve binding for interface {}",
             interface_name
         ))?;
 
-        let interface_box_result = binding_injectable.cast::<InterfaceTrait>();
+        match binding_providable {
+            Providable::Injectable(binding_injectable) => {
+                let interface_box_result = binding_injectable.cast::<Interface>();
+
+                match interface_box_result {
+                    Ok(interface_box) => Ok(interface_box),
+                    Err(_) => Err(Report::new(DIContainerError).attach_printable(
+                        format!("Unable to cast binding for {}", interface_name),
+                    )),
+                }
+            }
+            Providable::Factory(_) => Err(Report::new(DIContainerError)
+                .attach_printable(format!(
+                    "Binding for {} is not injectable",
+                    interface_name
+                ))),
+        }
+    }
+
+    /// Returns the factory bound with factory type `Interface`.
+    pub fn get_factory<Interface>(
+        &self,
+    ) -> error_stack::Result<Rc<Interface>, DIContainerError>
+    where
+        Interface: 'static + ?Sized,
+    {
+        let interface_typeid = TypeId::of::<Interface>();
+
+        let interface_name = type_name::<Interface>();
+
+        let binding = self._bindings.get(&interface_typeid).ok_or_else(|| {
+            Report::new(DIContainerError)
+                .attach_printable(format!("No binding exists for {}", interface_name))
+        })?;
+
+        let binding_providable = binding
+            .provide(self)
+            .change_context(DIContainerError)
+            .attach_printable(format!(
+            "Failed to resolve binding for interface {}",
+            interface_name
+        ))?;
 
-        match interface_box_result {
-            Ok(interface_box) => Ok(interface_box),
-            Err(_) => Err(Report::new(DIContainerError).attach_printable(format!(
-                "Unable to cast binding for {}",
-                interface_name
-            ))),
+        match binding_providable {
+            Providable::Factory(binding_factory) => {
+                let factory_box_result = binding_factory.cast::<Interface>();
+
+                match factory_box_result {
+                    Ok(interface_box) => Ok(interface_box),
+                    Err(_) => Err(Report::new(DIContainerError).attach_printable(
+                        format!("Unable to cast binding for {}", interface_name),
+                    )),
+                }
+            }
+            Providable::Injectable(_) => Err(Report::new(DIContainerError)
+                .attach_printable(format!(
+                    "Binding for {} is not a factory",
+                    interface_name
+                ))),
         }
     }
 }
diff --git a/syrette/src/interfaces/factory.rs b/syrette/src/interfaces/factory.rs
new file mode 100644
index 0000000..ed03cce
--- /dev/null
+++ b/syrette/src/interfaces/factory.rs
@@ -0,0 +1,7 @@
+use crate::libs::intertrait::CastFrom;
+
+pub trait IFactory<Args, Return>: Fn<Args, Output = Box<Return>> + CastFrom
+where
+    Return: 'static + ?Sized,
+{
+}
diff --git a/syrette/src/interfaces/mod.rs b/syrette/src/interfaces/mod.rs
index 31e53af..921bb9c 100644
--- a/syrette/src/interfaces/mod.rs
+++ b/syrette/src/interfaces/mod.rs
@@ -1 +1,2 @@
+pub mod factory;
 pub mod injectable;
diff --git a/syrette/src/lib.rs b/syrette/src/lib.rs
index 7278c37..945c0c0 100644
--- a/syrette/src/lib.rs
+++ b/syrette/src/lib.rs
@@ -1,3 +1,5 @@
+#![feature(unboxed_closures, fn_traits)]
+
 //! Syrette
 //!
 //! Syrette is a collection of utilities useful for performing dependency injection.
@@ -115,6 +117,7 @@
 //!
 //! ```
 
+pub mod castable_factory;
 pub mod di_container;
 pub mod errors;
 pub mod interfaces;
diff --git a/syrette/src/libs/intertrait/cast_rc.rs b/syrette/src/libs/intertrait/cast_rc.rs
new file mode 100644
index 0000000..58d212a
--- /dev/null
+++ b/syrette/src/libs/intertrait/cast_rc.rs
@@ -0,0 +1,34 @@
+/**
+ * Originally from Intertrait by CodeChain
+ *
+ * https://github.com/CodeChain-io/intertrait
+ * https://crates.io/crates/intertrait/0.2.2
+ *
+ * Licensed under either of
+ *
+ * Apache License, Version 2.0 (LICENSE-APACHE or http://www.apache.org/licenses/LICENSE-2.0)
+ * MIT license (LICENSE-MIT or http://opensource.org/licenses/MIT)
+
+ * at your option.
+*/
+use std::rc::Rc;
+
+use crate::libs::intertrait::{caster, CastFrom};
+
+pub trait CastRc
+{
+    /// Casts an `Rc` for this trait into that for type `T`.
+    fn cast<T: ?Sized + 'static>(self: Rc<Self>) -> Result<Rc<T>, Rc<Self>>;
+}
+
+/// A blanket implementation of `CastRc` for traits extending `CastFrom`.
+impl<S: ?Sized + CastFrom> CastRc for S
+{
+    fn cast<T: ?Sized + 'static>(self: Rc<Self>) -> Result<Rc<T>, Rc<Self>>
+    {
+        match caster::<T>((*self).type_id()) {
+            Some(caster) => Ok((caster.cast_rc)(self.rc_any())),
+            None => Err(self),
+        }
+    }
+}
diff --git a/syrette/src/libs/intertrait/mod.rs b/syrette/src/libs/intertrait/mod.rs
index b07d91e..e7b3bdd 100644
--- a/syrette/src/libs/intertrait/mod.rs
+++ b/syrette/src/libs/intertrait/mod.rs
@@ -27,6 +27,7 @@ mod hasher;
 use hasher::BuildFastHasher;
 
 pub mod cast_box;
+pub mod cast_rc;
 
 pub type BoxedCaster = Box<dyn Any + Send + Sync>;
 
diff --git a/syrette/src/provider.rs b/syrette/src/provider.rs
index 0d6a1cc..800315f 100644
--- a/syrette/src/provider.rs
+++ b/syrette/src/provider.rs
@@ -1,17 +1,25 @@
 use std::marker::PhantomData;
+use std::rc::Rc;
 
-extern crate error_stack;
-
+use crate::castable_factory::AnyFactory;
 use crate::errors::injectable::ResolveError;
 use crate::interfaces::injectable::Injectable;
 use crate::DIContainer;
 
-pub trait IInjectableTypeProvider
+extern crate error_stack;
+
+pub enum Providable
+{
+    Injectable(Box<dyn Injectable>),
+    Factory(Rc<dyn AnyFactory>),
+}
+
+pub trait IProvider
 {
     fn provide(
         &self,
         di_container: &DIContainer,
-    ) -> error_stack::Result<Box<dyn Injectable>, ResolveError>;
+    ) -> error_stack::Result<Providable, ResolveError>;
 }
 
 pub struct InjectableTypeProvider<InjectableType>
@@ -33,15 +41,41 @@ where
     }
 }
 
-impl<InjectableType> IInjectableTypeProvider for InjectableTypeProvider<InjectableType>
+impl<InjectableType> IProvider for InjectableTypeProvider<InjectableType>
 where
     InjectableType: Injectable,
 {
     fn provide(
         &self,
         di_container: &DIContainer,
-    ) -> error_stack::Result<Box<dyn Injectable>, ResolveError>
+    ) -> error_stack::Result<Providable, ResolveError>
+    {
+        Ok(Providable::Injectable(InjectableType::resolve(
+            di_container,
+        )?))
+    }
+}
+
+pub struct FactoryProvider
+{
+    _factory: Rc<dyn AnyFactory>,
+}
+
+impl FactoryProvider
+{
+    pub fn new(factory: Rc<dyn AnyFactory>) -> Self
+    {
+        Self { _factory: factory }
+    }
+}
+
+impl IProvider for FactoryProvider
+{
+    fn provide(
+        &self,
+        _di_container: &DIContainer,
+    ) -> error_stack::Result<Providable, ResolveError>
     {
-        Ok(InjectableType::resolve(di_container)?)
+        Ok(Providable::Factory(self._factory.clone()))
     }
 }
diff --git a/syrette_macros/src/lib.rs b/syrette_macros/src/lib.rs
index 1761534..0302c07 100644
--- a/syrette_macros/src/lib.rs
+++ b/syrette_macros/src/lib.rs
@@ -2,8 +2,8 @@ use proc_macro::TokenStream;
 use quote::{quote, ToTokens};
 use syn::{
     parse, parse_macro_input, parse_str, punctuated::Punctuated, token::Comma,
-    AttributeArgs, FnArg, GenericArgument, ImplItem, ItemImpl, Meta, NestedMeta, Path,
-    PathArguments, Type, TypePath,
+    AttributeArgs, ExprMethodCall, FnArg, GenericArgument, ImplItem, ItemImpl, ItemType,
+    Meta, NestedMeta, Path, PathArguments, Type, TypeParamBound, TypePath,
 };
 
 mod libs;
@@ -27,8 +27,16 @@ const IMPL_NO_NEW_METHOD_ERR_MESSAGE: &str =
 const IMPL_NEW_METHOD_SELF_PARAM_ERR_MESSAGE: &str =
     "The new method of the attached to trait implementation cannot have a self parameter";
 
-const IMPL_NEW_METHOD_BOX_PARAMS_ERR_MESSAGE: &str =
-    "All parameters of the new method of the attached to trait implementation must be std::boxed::Box";
+const IMPL_NEW_METHOD_PARAM_TYPES_ERR_MESSAGE: &str = concat!(
+    "All parameters of the new method of the attached to trait implementation ",
+    "must be either std::boxed::Box or std::rc:Rc (for factories)"
+);
+
+const INVALID_ALIASED_FACTORY_TRAIT_ERR_MESSAGE: &str =
+    "Invalid aliased trait. Must be 'dyn IFactory'";
+
+const INVALID_ALIASED_FACTORY_ARGS_ERR_MESSAGE: &str =
+    "Invalid arguments for 'dyn IFactory'";
 
 fn path_to_string(path: &Path) -> String
 {
@@ -67,6 +75,10 @@ fn get_fn_arg_type_paths(fn_args: &Punctuated<FnArg, Comma>) -> Vec<TypePath>
         match arg {
             FnArg::Typed(typed_fn_arg) => match typed_fn_arg.ty.as_ref() {
                 Type::Path(arg_type_path) => acc.push(arg_type_path.clone()),
+                Type::Reference(ref_type_path) => match ref_type_path.elem.as_ref() {
+                    Type::Path(arg_type_path) => acc.push(arg_type_path.clone()),
+                    &_ => {}
+                },
                 &_ => {}
             },
             FnArg::Receiver(_receiver_fn_arg) => {}
@@ -109,8 +121,11 @@ fn get_dependency_types(item_impl: &ItemImpl) -> Vec<Type>
             if arg_type_path_string != "Box"
                 && arg_type_path_string != "std::boxed::Box"
                 && arg_type_path_string != "boxed::Box"
+                && arg_type_path_string != "Rc"
+                && arg_type_path_string != "std::rc::Rc"
+                && arg_type_path_string != "rc::Rc"
             {
-                panic!("{}", IMPL_NEW_METHOD_BOX_PARAMS_ERR_MESSAGE);
+                panic!("{}", IMPL_NEW_METHOD_PARAM_TYPES_ERR_MESSAGE);
             }
 
             // Assume the type path has a last segment.
@@ -202,6 +217,49 @@ pub fn injectable(args_stream: TokenStream, impl_stream: TokenStream) -> TokenSt
 
     let dependency_types = get_dependency_types(&item_impl);
 
+    let get_dependencies = dependency_types.iter().fold(
+        Vec::<ExprMethodCall>::new(),
+        |mut acc, dep_type| {
+            match dep_type {
+                Type::TraitObject(dep_type_trait) => {
+                    acc.push(
+                        parse_str(
+                            format!(
+                                "di_container.get::<{}>()",
+                                dep_type_trait.to_token_stream()
+                            )
+                            .as_str(),
+                        )
+                        .unwrap(),
+                    );
+                }
+                Type::Path(dep_type_path) => {
+                    let dep_type_path_str = path_to_string(&dep_type_path.path);
+
+                    let get_method_name = if dep_type_path_str.ends_with("Factory") {
+                        "get_factory"
+                    } else {
+                        "get"
+                    };
+
+                    acc.push(
+                        parse_str(
+                            format!(
+                                "di_container.{}::<{}>()",
+                                get_method_name, dep_type_path_str
+                            )
+                            .as_str(),
+                        )
+                        .unwrap(),
+                    );
+                }
+                &_ => {}
+            }
+
+            acc
+        },
+    );
+
     quote! {
         #item_impl
 
@@ -213,13 +271,15 @@ pub fn injectable(args_stream: TokenStream, impl_stream: TokenStream) -> TokenSt
                 use error_stack::ResultExt;
 
                 return Ok(Box::new(Self::new(
-                    #(di_container.get::<#dependency_types>()
+                    #(#get_dependencies
                         .change_context(syrette::errors::injectable::ResolveError)
-                        .attach_printable(format!(
-                            "Unable to resolve a dependency of {}",
-                            std::any::type_name::<#self_type_path>()
-                        ))?,
-                    )*
+                        .attach_printable(
+                            format!(
+                                "Unable to resolve a dependency of {}",
+                                std::any::type_name::<#self_type_path>()
+                            )
+                        )?
+                    ),*
                 )));
             }
         }
@@ -229,6 +289,73 @@ pub fn injectable(args_stream: TokenStream, impl_stream: TokenStream) -> TokenSt
     .into()
 }
 
+#[proc_macro_attribute]
+pub fn factory(_: TokenStream, type_alias_stream: TokenStream) -> TokenStream
+{
+    let type_alias: ItemType = parse(type_alias_stream).unwrap();
+
+    let aliased_trait = match &type_alias.ty.as_ref() {
+        Type::TraitObject(alias_type) => alias_type,
+        &_ => panic!("{}", INVALID_ALIASED_FACTORY_TRAIT_ERR_MESSAGE),
+    };
+
+    if aliased_trait.bounds.len() != 1 {
+        panic!("{}", INVALID_ALIASED_FACTORY_TRAIT_ERR_MESSAGE);
+    }
+
+    let type_bound = aliased_trait.bounds.first().unwrap();
+
+    let trait_bound = match type_bound {
+        TypeParamBound::Trait(trait_bound) => trait_bound,
+        &_ => panic!("{}", INVALID_ALIASED_FACTORY_TRAIT_ERR_MESSAGE),
+    };
+
+    let trait_bound_path = &trait_bound.path;
+
+    if trait_bound_path.segments.is_empty()
+        || trait_bound_path.segments.last().unwrap().ident != "IFactory"
+    {
+        panic!("{}", INVALID_ALIASED_FACTORY_TRAIT_ERR_MESSAGE);
+    }
+
+    let factory_path_segment = trait_bound_path.segments.last().unwrap();
+
+    let factory_path_segment_args = &match &factory_path_segment.arguments {
+        syn::PathArguments::AngleBracketed(args) => args,
+        &_ => panic!("{}", INVALID_ALIASED_FACTORY_ARGS_ERR_MESSAGE),
+    }
+    .args;
+
+    let factory_arg_types_type = match &factory_path_segment_args[0] {
+        GenericArgument::Type(arg_type) => arg_type,
+        &_ => panic!("{}", INVALID_ALIASED_FACTORY_ARGS_ERR_MESSAGE),
+    };
+
+    let factory_return_type = match &factory_path_segment_args[1] {
+        GenericArgument::Type(arg_type) => arg_type,
+        &_ => panic!("{}", INVALID_ALIASED_FACTORY_ARGS_ERR_MESSAGE),
+    };
+
+    quote! {
+        #type_alias
+
+        syrette::castable_to!(
+            syrette::castable_factory::CastableFactory<
+                #factory_arg_types_type,
+                #factory_return_type
+            > => #trait_bound_path
+        );
+
+        syrette::castable_to!(
+            syrette::castable_factory::CastableFactory<
+                #factory_arg_types_type,
+                #factory_return_type
+            > => syrette::castable_factory::AnyFactory
+        );
+    }
+    .into()
+}
+
 #[doc(hidden)]
 #[proc_macro]
 pub fn castable_to(input: TokenStream) -> TokenStream