Allow context types to delegate components directly (#175)

* Use DelegateComponent in consumer blanket implementation directly

* Remove HasCgpProvider trait

* Remove HasCgpProvider from comments

* Move component tests to separate test unit

* Add basic consumer delegate test

* Test generic consumer delegate

* Move preset tests into separate test unit

* Test consumer delegation in preset

Author: soareschen

crates/cgp-component/src/lib.rs

@@ -8,5 +8,5 @@
 mod traits;
 mod types;
 
-pub use traits::{CanUseComponent, DelegateComponent, HasCgpProvider, IsProviderFor};
+pub use traits::{CanUseComponent, DelegateComponent, IsProviderFor};
 pub use types::{UseContext, UseDelegate, UseFields, WithContext, WithProvider};

crates/cgp-component/src/traits/can_use_component.rs

@@ -1,13 +1,13 @@
-use crate::{HasCgpProvider, IsProviderFor};
+use crate::{DelegateComponent, IsProviderFor};
 
 /**
     This is a convenient type alias that is used in the same way as [`IsProviderFor`],
     but with the `Self` type being the `Context` type rather than the `Provider` type
     that implements the provider trait.
 
     The `CanUseComponent` trait is automatically implemented for any CGP `Context` type
-    that implements the `HasCgpProvider` trait, and when `Contex::CgpProvider` implements
-    `IsProviderFor<Component, Context, Params>`.
+    that implements the `DelegateComponent<Component>` trait, and when `Contex::Delegate`
+    implements `IsProviderFor<Component, Context, Params>`.
 
     This trait is used by `check_components!` to check whether a `Context` implements
     a given `Component` through its provider. When there are unsatisfied constraints,
@@ -17,7 +17,7 @@ pub trait CanUseComponent<Component, Params: ?Sized = ()> {}
 
 impl<Context, Component, Params: ?Sized> CanUseComponent<Component, Params> for Context
 where
-    Context: HasCgpProvider,
-    Context::CgpProvider: IsProviderFor<Component, Context, Params>,
+    Context: DelegateComponent<Component>,
+    Context::Delegate: IsProviderFor<Component, Context, Params>,
 {
 }

crates/cgp-component/src/traits/has_provider.rs

@@ -1,9 +1,7 @@
 mod can_use_component;
 mod delegate_component;
-mod has_provider;
 mod is_provider;
 
 pub use can_use_component::*;
 pub use delegate_component::DelegateComponent;
-pub use has_provider::HasCgpProvider;
 pub use is_provider::*;

crates/cgp-component/src/traits/mod.rs

@@ -2,8 +2,8 @@ pub use core::marker::PhantomData;
 
 pub use cgp_async_macro::async_trait;
 pub use cgp_component::{
-    CanUseComponent, DelegateComponent, HasCgpProvider, IsProviderFor, UseContext, UseDelegate,
-    UseFields, WithContext, WithProvider,
+    CanUseComponent, DelegateComponent, IsProviderFor, UseContext, UseDelegate, UseFields,
+    WithContext, WithProvider,
 };
 pub use cgp_error::{CanRaiseError, CanWrapError, HasErrorType};
 pub use cgp_field::impls::{IsMut, IsNothing, IsPresent, IsRef, IsVoid, UseField};

crates/cgp-core/src/prelude.rs

@@ -1,4 +1,4 @@
-use cgp_component::{DelegateComponent, HasCgpProvider, IsProviderFor, UseContext, UseDelegate};
+use cgp_component::{DelegateComponent, IsProviderFor, UseContext, UseDelegate};
 use cgp_macro::cgp_component;
 
 use crate::traits::has_error_type::HasErrorType;

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

@@ -1,4 +1,4 @@
-use cgp_component::{DelegateComponent, HasCgpProvider, IsProviderFor, UseContext, UseDelegate};
+use cgp_component::{DelegateComponent, IsProviderFor, UseContext, UseDelegate};
 use cgp_macro::cgp_component;
 
 use crate::traits::HasErrorType;

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

@@ -1,6 +1,6 @@
 use core::fmt::Debug;
 
-use cgp_component::{DelegateComponent, HasCgpProvider, IsProviderFor, UseContext, WithProvider};
+use cgp_component::{DelegateComponent, IsProviderFor, UseContext, WithProvider};
 use cgp_macro::cgp_type;
 use cgp_type::{ProvideType, UseType};
 

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

@@ -3,8 +3,9 @@ use alloc::vec::Vec;
 
 use proc_macro2::Span;
 use quote::{ToTokens, quote};
+use syn::punctuated::Punctuated;
 use syn::spanned::Spanned;
-use syn::token::{Brace, Eq, For, Impl};
+use syn::token::{Brace, Comma, Eq, For, Impl};
 use syn::{
     Error, GenericParam, Generics, Ident, ImplItem, ImplItemConst, ItemImpl, ItemTrait, Path,
     TraitItem, TypeParamBound, Visibility, parse2,
@@ -17,6 +18,8 @@ pub fn derive_consumer_impl(
     consumer_trait: &ItemTrait,
     provider_name: &Ident,
     context_type: &Ident,
+    component_name: &Ident,
+    component_params: &Punctuated<Ident, Comma>,
 ) -> syn::Result<ItemImpl> {
     let consumer_name = &consumer_trait.ident;
 
@@ -61,7 +64,7 @@ pub fn derive_consumer_impl(
 
         {
             let has_component_constraint: TypeParamBound = parse2(quote! {
-                HasCgpProvider
+                DelegateComponent< #component_name < #component_params > >
             })?;
 
             let provider_constraint: TypeParamBound = parse2(quote! {
@@ -75,14 +78,14 @@ pub fn derive_consumer_impl(
                     })?);
 
                     where_clause.predicates.push(parse2(quote! {
-                        #context_type :: CgpProvider : #provider_constraint
+                        #context_type :: Delegate : #provider_constraint
                     })?);
                 }
                 _ => {
                     generics.where_clause = Some(parse2(quote! {
                         where
                             #context_type : #has_component_constraint,
-                            #context_type :: CgpProvider : #provider_constraint
+                            #context_type :: Delegate : #provider_constraint
                     })?);
                 }
             }
@@ -98,7 +101,7 @@ pub fn derive_consumer_impl(
             TraitItem::Fn(trait_fn) => {
                 let impl_fn = derive_delegated_fn_impl(
                     &trait_fn.sig,
-                    &parse2(quote!(#context_type :: CgpProvider))?,
+                    &parse2(quote!(#context_type :: Delegate))?,
                 )?;
 
                 impl_items.push(ImplItem::Fn(impl_fn));
@@ -121,7 +124,7 @@ pub fn derive_consumer_impl(
                 let impl_type = derive_delegate_type_impl(
                     trait_type,
                     parse2(quote!(
-                        < #context_type :: CgpProvider as #provider_name < #provider_type_generics > > :: #type_name #type_generics
+                        < #context_type :: Delegate as #provider_name < #provider_type_generics > > :: #type_name #type_generics
                     ))?,
                 );
 
@@ -132,7 +135,7 @@ pub fn derive_consumer_impl(
                 let (_, type_generics, _) = trait_item_const.generics.split_for_impl();
 
                 let impl_expr = parse2(quote! {
-                    < #context_type :: CgpProvider as #provider_name < #provider_type_generics > > :: #const_ident #type_generics
+                    < #context_type :: Delegate as #provider_name < #provider_type_generics > > :: #const_ident #type_generics
                 })?;
 
                 let impl_item_const = ImplItemConst {

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

@@ -31,7 +31,13 @@ pub fn derive_component_with_ast(
         context_type,
     )?;
 
-    let consumer_impl = derive_consumer_impl(&consumer_trait, provider_name, context_type)?;
+    let consumer_impl = derive_consumer_impl(
+        &consumer_trait,
+        provider_name,
+        context_type,
+        component_name,
+        component_params,
+    )?;
 
     let provider_impl = derive_provider_impl(
         context_type,