Support derivation of UseDelegate inside #[cgp_component] (#106)

* Scaffold parsing of use_delegate param in #[cgp_component]

* Draft implement derive_use_delegate_impl

* Parse use_delegate spec into list of idents

* Derive UseDelegate in main derive

* deriving UseDelegate is working

* Derive UseDelegate automatically

* Generalize syntax of use_delegate

* Allow multiple delegate derivations

* Rename AST to DeriveDelegateSpec

* Support arbitrary TokenStream value in component entry

* Allow use of bracket as component spec value

* Test use of derive_delegate

Author: soareschen

crates/cgp-error/src/traits/can_raise_error.rs

@@ -1,5 +1,5 @@
 use cgp_component::{DelegateComponent, HasCgpProvider, IsProviderFor, UseContext, UseDelegate};
-use cgp_macro::{cgp_component, cgp_provider};
+use cgp_macro::cgp_component;
 
 use crate::traits::has_error_type::HasErrorType;
 
@@ -12,21 +12,9 @@ use crate::traits::has_error_type::HasErrorType;
    a [`Context::Error`](HasErrorType::Error) value.
 */
 #[cgp_component {
-    provider: ErrorRaiser
+    provider: ErrorRaiser,
+    derive_delegate: UseDelegate<SourceError>,
 }]
 pub trait CanRaiseError<SourceError>: HasErrorType {
     fn raise_error(error: SourceError) -> Self::Error;
 }
-
-#[cgp_provider(ErrorRaiserComponent)]
-impl<Context, SourceError, Components, Delegate> ErrorRaiser<Context, SourceError>
-    for UseDelegate<Components>
-where
-    Context: HasErrorType,
-    Components: DelegateComponent<SourceError, Delegate = Delegate>,
-    Delegate: ErrorRaiser<Context, SourceError>,
-{
-    fn raise_error(e: SourceError) -> Context::Error {
-        Delegate::raise_error(e)
-    }
-}

crates/cgp-error/src/traits/can_wrap_error.rs

@@ -1,23 +1,12 @@
 use cgp_component::{DelegateComponent, HasCgpProvider, IsProviderFor, UseContext, UseDelegate};
-use cgp_macro::{cgp_component, cgp_provider};
+use cgp_macro::cgp_component;
 
 use crate::traits::HasErrorType;
 
 #[cgp_component {
     provider: ErrorWrapper,
+    derive_delegate: UseDelegate<Detail>,
 }]
 pub trait CanWrapError<Detail>: HasErrorType {
     fn wrap_error(error: Self::Error, detail: Detail) -> Self::Error;
 }
-
-#[cgp_provider(ErrorWrapperComponent)]
-impl<Context, Detail, Components> ErrorWrapper<Context, Detail> for UseDelegate<Components>
-where
-    Context: HasErrorType,
-    Components: DelegateComponent<Detail>,
-    Components::Delegate: ErrorWrapper<Context, Detail>,
-{
-    fn wrap_error(error: Context::Error, detail: Detail) -> Context::Error {
-        Components::Delegate::wrap_error(error, detail)
-    }
-}

crates/cgp-handler/src/components/compute.rs

@@ -3,23 +3,12 @@ use core::marker::PhantomData;
 use cgp_core::component::UseDelegate;
 use cgp_core::prelude::*;
 
-#[cgp_component(Computer)]
+#[cgp_component {
+    provider: Computer,
+    derive_delegate: UseDelegate<Code>,
+}]
 pub trait CanCompute<Code, Input> {
     type Output;
 
     fn compute(&self, _tag: PhantomData<Code>, input: Input) -> Self::Output;
 }
-
-#[cgp_provider]
-impl<Context, Code, Input, Components, Delegate> Computer<Context, Code, Input>
-    for UseDelegate<Components>
-where
-    Components: DelegateComponent<Code, Delegate = Delegate>,
-    Delegate: Computer<Context, Code, Input>,
-{
-    type Output = Delegate::Output;
-
-    fn compute(context: &Context, tag: PhantomData<Code>, input: Input) -> Self::Output {
-        Delegate::compute(context, tag, input)
-    }
-}

crates/cgp-handler/src/components/handler.rs

@@ -3,7 +3,10 @@ use core::marker::PhantomData;
 use cgp_core::component::UseDelegate;
 use cgp_core::prelude::*;
 
-#[cgp_component(Handler)]
+#[cgp_component {
+    provider: Handler,
+    derive_delegate: UseDelegate<Code>,
+}]
 #[async_trait]
 pub trait CanHandle<Code: Send, Input: Send>: HasAsyncErrorType {
     type Output: Send;
@@ -14,24 +17,3 @@ pub trait CanHandle<Code: Send, Input: Send>: HasAsyncErrorType {
         input: Input,
     ) -> Result<Self::Output, Self::Error>;
 }
-
-#[cgp_provider]
-impl<Context, Code, Input, Components, Delegate> Handler<Context, Code, Input>
-    for UseDelegate<Components>
-where
-    Context: HasAsyncErrorType,
-    Components: DelegateComponent<Code, Delegate = Delegate>,
-    Delegate: Handler<Context, Code, Input>,
-    Code: Send,
-    Input: Send,
-{
-    type Output = Delegate::Output;
-
-    async fn handle(
-        context: &Context,
-        tag: PhantomData<Code>,
-        input: Input,
-    ) -> Result<Self::Output, Context::Error> {
-        Delegate::handle(context, tag, input).await
-    }
-}

crates/cgp-handler/src/components/produce.rs

@@ -3,24 +3,12 @@ use core::marker::PhantomData;
 use cgp_core::component::UseDelegate;
 use cgp_core::prelude::*;
 
-#[cgp_component(Producer)]
+#[cgp_component {
+    provider: Producer,
+    derive_delegate: UseDelegate<Code>,
+}]
 pub trait CanProduce<Code> {
     type Output;
 
     fn produce(&self, _tag: PhantomData<Code>) -> Self::Output;
 }
-
-#[cgp_provider]
-impl<Context, Code, Components, Delegate> Producer<Context, Code> for UseDelegate<Components>
-where
-    Context: HasAsyncErrorType,
-    Components: DelegateComponent<Code, Delegate = Delegate>,
-    Delegate: Producer<Context, Code>,
-    Code: Send,
-{
-    type Output = Delegate::Output;
-
-    fn produce(context: &Context, tag: PhantomData<Code>) -> Self::Output {
-        Delegate::produce(context, tag)
-    }
-}

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

@@ -1,12 +1,13 @@
 use proc_macro2::TokenStream;
-use quote::{quote, ToTokens};
+use quote::{quote, ToTokens, TokenStreamExt};
 use syn::{parse2, ItemImpl, ItemStruct, ItemTrait};
 
 use crate::derive_component::component_name::derive_component_name_struct;
 use crate::derive_component::consumer_impl::derive_consumer_impl;
 use crate::derive_component::provider_impl::derive_provider_impl;
 use crate::derive_component::provider_trait::derive_provider_trait;
 use crate::derive_component::use_context_impl::derive_use_context_impl;
+use crate::derive_component::use_delegate_impl::derive_delegate_impl;
 use crate::derive_provider::derive_is_provider_for;
 use crate::parse::ComponentSpec;
 
@@ -49,14 +50,34 @@ pub fn derive_component_with_ast(
         &use_context_impl,
     )?;
 
-    let derived = DerivedComponent {
-        component_struct,
-        consumer_trait,
-        provider_trait,
+    let mut item_impls = vec![
         consumer_impl,
         provider_impl,
         use_context_impl,
         use_context_is_provider_impl,
+    ];
+
+    if !spec.use_delegate_spec.is_empty() {
+        for spec in spec.use_delegate_spec.iter() {
+            let use_delegate_impl = derive_delegate_impl(&provider_trait, spec)?;
+
+            let use_delegate_is_provider_impl = derive_is_provider_for(
+                &parse2(quote! {
+                    #component_name < #component_params >
+                })?,
+                &use_delegate_impl,
+            )?;
+
+            item_impls.push(use_delegate_impl);
+            item_impls.push(use_delegate_is_provider_impl);
+        }
+    }
+
+    let derived = DerivedComponent {
+        component_struct,
+        consumer_trait,
+        provider_trait,
+        item_impls,
     };
 
     Ok(derived)
@@ -66,20 +87,14 @@ pub struct DerivedComponent {
     pub component_struct: ItemStruct,
     pub consumer_trait: ItemTrait,
     pub provider_trait: ItemTrait,
-    pub consumer_impl: ItemImpl,
-    pub provider_impl: ItemImpl,
-    pub use_context_impl: ItemImpl,
-    pub use_context_is_provider_impl: ItemImpl,
+    pub item_impls: Vec<ItemImpl>,
 }
 
 impl ToTokens for DerivedComponent {
     fn to_tokens(&self, tokens: &mut TokenStream) {
         self.component_struct.to_tokens(tokens);
         self.consumer_trait.to_tokens(tokens);
         self.provider_trait.to_tokens(tokens);
-        self.consumer_impl.to_tokens(tokens);
-        self.provider_impl.to_tokens(tokens);
-        self.use_context_impl.to_tokens(tokens);
-        self.use_context_is_provider_impl.to_tokens(tokens);
+        tokens.append_all(self.item_impls.iter());
     }
 }

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

@@ -10,6 +10,7 @@ mod replace_self_type;
 mod signature_args;
 mod snake_case;
 mod use_context_impl;
+mod use_delegate_impl;
 
 pub use derive::*;
 pub use replace_self_type::*;

crates/cgp-macro-lib/src/derive_component/use_context_impl.rs

@@ -3,8 +3,7 @@ use quote::quote;
 use syn::spanned::Spanned;
 use syn::token::{Brace, Eq, For, Impl};
 use syn::{
-    parse2, Error, GenericParam, Ident, ImplItem, ImplItemConst, ItemImpl, ItemTrait, Path,
-    TraitItem, Visibility,
+    parse2, Error, Ident, ImplItem, ImplItemConst, ItemImpl, ItemTrait, Path, TraitItem, Visibility,
 };
 
 use crate::derive_component::delegate_fn::derive_delegated_fn_impl;
@@ -34,7 +33,7 @@ pub fn derive_use_context_impl(
     let mut impl_items: Vec<ImplItem> = Vec::new();
 
     for trait_item in provider_trait.items.iter() {
-        match &trait_item {
+        match trait_item {
             TraitItem::Fn(trait_fn) => {
                 let impl_fn = derive_delegated_fn_impl(&trait_fn.sig, &quote!( #context_type ))?;
 
@@ -43,18 +42,7 @@ pub fn derive_use_context_impl(
             TraitItem::Type(trait_type) => {
                 let type_name = &trait_type.ident;
 
-                let type_generics = {
-                    let mut type_generics = trait_type.generics.clone();
-                    type_generics.where_clause = None;
-
-                    for param in &mut type_generics.params {
-                        if let GenericParam::Type(type_param) = param {
-                            type_param.bounds.clear();
-                        }
-                    }
-
-                    type_generics
-                };
+                let type_generics = trait_type.generics.split_for_impl().1;
 
                 let impl_type = derive_delegate_type_impl(
                     trait_type,

crates/cgp-macro-lib/src/derive_component/use_delegate_impl.rs

@@ -0,0 +1,124 @@
+use proc_macro2::Span;
+use quote::quote;
+use syn::spanned::Spanned;
+use syn::token::{Brace, Eq, For, Impl};
+use syn::{
+    parse2, Error, Ident, ImplItem, ImplItemConst, ItemImpl, ItemTrait, Path, TraitItem, Visibility,
+};
+
+use crate::derive_component::delegate_fn::derive_delegated_fn_impl;
+use crate::derive_component::delegate_type::derive_delegate_type_impl;
+use crate::parse::DeriveDelegateSpec;
+
+pub fn derive_delegate_impl(
+    provider_trait: &ItemTrait,
+    spec: &DeriveDelegateSpec,
+) -> syn::Result<ItemImpl> {
+    let provider_trait_ident = &provider_trait.ident;
+
+    let components_ident = Ident::new("__Components__", Span::call_site());
+    let delegate_ident = Ident::new("__Delegate__", Span::call_site());
+
+    let wrapper_ident = &spec.wrapper;
+    let use_delegate_params = &spec.params;
+
+    let generics = {
+        let mut generics = provider_trait.generics.clone();
+
+        generics.params.push(parse2(quote!( #components_ident ))?);
+        generics.params.push(parse2(quote!( #delegate_ident ))?);
+
+        let where_clause = generics.make_where_clause();
+
+        where_clause.predicates.push(parse2(quote! {
+            #components_ident: DelegateComponent<
+                ( #use_delegate_params ),
+                Delegate = #delegate_ident,
+            >
+        })?);
+
+        let type_generics = provider_trait.generics.split_for_impl().1;
+
+        where_clause.predicates.push(parse2(quote! {
+            #delegate_ident : #provider_trait_ident #type_generics
+        })?);
+
+        generics
+    };
+
+    let (_, type_generics, _) = provider_trait.generics.split_for_impl();
+
+    let trait_path: Path = parse2(quote!( #provider_trait_ident #type_generics ))?;
+
+    let mut impl_items: Vec<ImplItem> = Vec::new();
+
+    for trait_item in provider_trait.items.iter() {
+        match trait_item {
+            TraitItem::Fn(trait_fn) => {
+                let impl_fn = derive_delegated_fn_impl(&trait_fn.sig, &quote!( #delegate_ident ))?;
+
+                impl_items.push(ImplItem::Fn(impl_fn))
+            }
+            TraitItem::Type(trait_type) => {
+                let type_name = &trait_type.ident;
+
+                let type_generics = trait_type.generics.split_for_impl().1;
+
+                let impl_type = derive_delegate_type_impl(
+                    trait_type,
+                    parse2(quote!(
+                        #delegate_ident :: #type_name #type_generics
+                    ))?,
+                );
+
+                impl_items.push(ImplItem::Type(impl_type));
+            }
+            TraitItem::Const(trait_item_const) => {
+                let const_ident = &trait_item_const.ident;
+                let (_, type_generics, _) = trait_item_const.generics.split_for_impl();
+
+                let impl_expr = parse2(quote! {
+                    #delegate_ident :: #const_ident #type_generics
+                })?;
+
+                let impl_item_const = ImplItemConst {
+                    attrs: trait_item_const.attrs.clone(),
+                    vis: Visibility::Inherited,
+                    defaultness: None,
+                    const_token: trait_item_const.const_token,
+                    ident: trait_item_const.ident.clone(),
+                    generics: trait_item_const.generics.clone(),
+                    colon_token: trait_item_const.colon_token,
+                    ty: trait_item_const.ty.clone(),
+                    eq_token: Eq(Span::call_site()),
+                    expr: impl_expr,
+                    semi_token: trait_item_const.semi_token,
+                };
+
+                impl_items.push(ImplItem::Const(impl_item_const));
+            }
+            _ => {
+                return Err(Error::new(
+                    trait_item.span(),
+                    format!("unsupported trait item: {trait_item:?}"),
+                ));
+            }
+        }
+    }
+
+    let provider_type = parse2(quote!(#wrapper_ident < #components_ident >))?;
+
+    let item = ItemImpl {
+        attrs: provider_trait.attrs.clone(),
+        defaultness: None,
+        unsafety: provider_trait.unsafety,
+        impl_token: Impl::default(),
+        generics,
+        trait_: Some((None, trait_path, For::default())),
+        self_ty: Box::new(provider_type),
+        brace_token: Brace::default(),
+        items: impl_items,
+    };
+
+    Ok(item)
+}