Preset Macro Improvements

crates/cgp-macro-lib/src/delegate_components/impl_delegate.rs

@@ -2,20 +2,25 @@ use alloc::boxed::Box;
 use alloc::vec;
 use alloc::vec::Vec;
 
-use quote::quote;
+use quote::{quote, ToTokens};
+use syn::punctuated::Punctuated;
+use syn::token::Comma;
 use syn::{parse2, ImplItem, ImplItemType, ItemImpl, Path, Type};
 
 use crate::delegate_components::merge_generics::merge_generics;
-use crate::parse::{DelegateComponentEntries, DelegateComponentName, ImplGenerics};
+use crate::parse::{DelegateComponentEntry, DelegateComponentName, ImplGenerics};
 
-pub fn impl_delegate_components(
+pub fn impl_delegate_components<T>(
     target_type: &Type,
     target_generics: &ImplGenerics,
-    delegate_entries: &DelegateComponentEntries,
-) -> syn::Result<Vec<ItemImpl>> {
+    delegate_entries: &Punctuated<DelegateComponentEntry<T>, Comma>,
+) -> syn::Result<Vec<ItemImpl>>
+where
+    T: ToTokens,
+{
     let mut components = Vec::new();
 
-    for entry in delegate_entries.entries.iter() {
+    for entry in delegate_entries.iter() {
         let source = &entry.source;
         for component in entry.components.iter() {
             let mut impls =
@@ -27,12 +32,15 @@ pub fn impl_delegate_components(
     Ok(components)
 }
 
-pub fn impl_delegate_component(
+pub fn impl_delegate_component<T>(
     target_type: &Type,
     target_generics: &ImplGenerics,
-    component: &DelegateComponentName,
+    component: &DelegateComponentName<T>,
     source: &Type,
-) -> syn::Result<Vec<ItemImpl>> {
+) -> syn::Result<Vec<ItemImpl>>
+where
+    T: ToTokens,
+{
     let component_type = &component.component_type;
 
     let delegate_trait_path: Path = parse2(quote!(DelegateComponent < #component_type >))?;

crates/cgp-macro-lib/src/delegate_components/mod.rs

@@ -1,8 +1,6 @@
 mod define_struct;
-mod delegates_to;
 mod impl_delegate;
 mod merge_generics;
 
 pub use define_struct::*;
-pub use delegates_to::*;
 pub use impl_delegate::*;

crates/cgp-macro-lib/src/derive_context/derive.rs

@@ -1,10 +1,11 @@
 use quote::quote;
-use syn::{parse2, parse_quote, Ident, ItemImpl, ItemStruct, Path};
+use syn::{parse2, parse_quote, AngleBracketedGenericArguments, Ident, ItemImpl, ItemStruct};
 
 use crate::parse::TypeGenerics;
 
 pub fn derive_has_components(
     provider_name: &Ident,
+    provider_generics: &Option<TypeGenerics>,
     context_struct: &ItemStruct,
 ) -> syn::Result<ItemImpl> {
     let context_name = &context_struct.ident;
@@ -15,42 +16,53 @@ pub fn derive_has_components(
         impl #impl_generics HasProvider for #context_name #ty_generics
             #where_clause
         {
-            type Provider = #provider_name;
+            type Provider = #provider_name #provider_generics;
         }
     })
 }
 
 pub fn derive_delegate_preset(
     provider_name: &Ident,
+    provider_generics: &Option<TypeGenerics>,
     preset_name: &Ident,
-    preset_generics: &Option<TypeGenerics>,
+    preset_generics: &Option<AngleBracketedGenericArguments>,
 ) -> syn::Result<(ItemImpl, ItemImpl)> {
-    let preset_trait_name: Path = parse2(quote! {
+    let provider_params = match provider_generics {
+        Some(generics) => {
+            let params = &generics.generics.params;
+            quote! {
+                , #params
+            }
+        }
+        None => quote! {},
+    };
+
+    let preset_trait_name = quote! {
         #preset_name :: IsPreset
-    })?;
+    };
 
-    let preset_provider_name: Path = parse2(quote! {
-        #preset_name :: Provider
-    })?;
+    let preset_provider_name = quote! {
+        #preset_name :: Provider #preset_generics
+    };
 
     let delegate_impl: ItemImpl = parse_quote! {
-        impl<__Name__>
+        impl< __Name__ #provider_params >
             DelegateComponent<__Name__>
-            for #provider_name
+            for #provider_name #provider_generics
         where
             Self: #preset_trait_name < __Name__ >,
         {
-            type Delegate = #preset_provider_name #preset_generics ;
+            type Delegate = #preset_provider_name;
         }
     };
 
     let is_provider_impl: ItemImpl = parse_quote! {
-        impl<__Name__, __Context__, __Params__>
+        impl<__Name__, __Context__, __Params__ #provider_params >
             IsProviderFor<__Name__, __Context__, __Params__>
-            for #provider_name
+            for #provider_name #provider_generics
         where
             Self: #preset_trait_name < __Name__ >,
-            #preset_provider_name #preset_generics: IsProviderFor<__Name__, __Context__, __Params__>,
+            #preset_provider_name: IsProviderFor<__Name__, __Context__, __Params__>,
         {
         }
     };

crates/cgp-macro-lib/src/derive_provider/derive.rs

@@ -22,7 +22,7 @@ pub fn derive_provider_struct(provider_impl: &ItemImpl) -> syn::Result<ItemStruc
 
     let provider_field = match &provider_type.generics {
         Some(generics) => {
-            let args = &generics.generics.params;
+            let args = &generics.args;
             quote! {
                 #generics
                 ( pub ::core::marker::PhantomData<( #args )>  )

crates/cgp-macro-lib/src/entrypoints/cgp_context.rs

@@ -11,10 +11,21 @@ pub fn cgp_context(attr: TokenStream, body: TokenStream) -> syn::Result<TokenStr
     let context_struct: ItemStruct = syn::parse2(body)?;
 
     let provider_name = &context_spec.provider_name;
+    let provider_generics = &context_spec.provider_generics;
 
-    let provider_struct: ItemStruct = parse2(quote!( pub struct #provider_name; ))?;
+    let provider_phantom = match provider_generics {
+        Some(generics) => {
+            let params = &generics.generics.params;
+            quote! { ( ::core::marker::PhantomData<( #params )> ) }
+        }
+        None => quote! {},
+    };
+
+    let provider_struct: ItemStruct =
+        parse2(quote!( pub struct #provider_name #provider_generics #provider_phantom; ))?;
 
-    let has_components_impl: ItemImpl = derive_has_components(provider_name, &context_struct)?;
+    let has_components_impl: ItemImpl =
+        derive_has_components(provider_name, provider_generics, &context_struct)?;
 
     let base_derived = quote! {
         #context_struct
@@ -25,9 +36,13 @@ pub fn cgp_context(attr: TokenStream, body: TokenStream) -> syn::Result<TokenStr
     };
 
     match &context_spec.preset {
-        Some(preset) => {
-            let (delegate_impl, is_provider_impl) =
-                derive_delegate_preset(provider_name, &preset.name, &preset.generics)?;
+        Some((preset_path, preset_generics)) => {
+            let (delegate_impl, is_provider_impl) = derive_delegate_preset(
+                provider_name,
+                provider_generics,
+                preset_path,
+                preset_generics,
+            )?;
 
             Ok(quote! {
                 #base_derived