Refactoring and Improvements on #[cgp_getter]

crates/cgp-component-macro-lib/src/getter_component/blanket.rs

@@ -6,6 +6,7 @@ use syn::{parse2, Ident, ItemImpl, ItemTrait};
 
 use crate::getter_component::getter_field::GetterField;
 use crate::getter_component::symbol::symbol_from_string;
+use crate::getter_component::{derive_getter_constraint, derive_getter_method, ContextArg};
 
 pub fn derive_blanket_impl(
     context_type: &Ident,
@@ -19,31 +20,20 @@ pub fn derive_blanket_impl(
     let mut methods: TokenStream = TokenStream::new();
 
     for field in fields {
-        let field_name = &field.field_name;
-        let provider_type = &field.provider_type;
         let field_symbol = symbol_from_string(&field.field_name.to_string());
 
-        if field.field_mut.is_none() {
-            constraints.push(parse2(quote! {
-                HasField< #field_symbol, Value = #provider_type >
-            })?);
+        let method = derive_getter_method(
+            &ContextArg::SelfArg,
+            field,
+            Some(quote! { ::< #field_symbol > }),
+            None,
+        );
 
-            methods.extend(quote! {
-                fn #field_name( &self ) -> & #provider_type {
-                    self.get_field( ::core::marker::PhantomData::< #field_symbol > )
-                }
-            });
-        } else {
-            constraints.push(parse2(quote! {
-                HasFieldMut< #field_symbol, Value = #provider_type >
-            })?);
+        methods.extend(method);
 
-            methods.extend(quote! {
-                fn #field_name( &mut self ) -> &mut #provider_type {
-                    self.get_field_mut( ::core::marker::PhantomData::< #field_symbol > )
-                }
-            });
-        }
+        let constraint = derive_getter_constraint(field, quote! { #field_symbol })?;
+
+        constraints.push(constraint);
     }
 
     let (_, type_generics, _) = consumer_trait.generics.split_for_impl();

crates/cgp-component-macro-lib/src/getter_component/constraint.rs

@@ -0,0 +1,24 @@
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::{parse2, TypeParamBound};
+
+use crate::getter_component::GetterField;
+
+pub fn derive_getter_constraint(
+    spec: &GetterField,
+    field_symbol: TokenStream,
+) -> syn::Result<TypeParamBound> {
+    let provider_type = &spec.field_type;
+
+    let constraint = if spec.field_mut.is_none() {
+        quote! {
+            HasField< #field_symbol, Value = #provider_type >
+        }
+    } else {
+        quote! {
+            HasFieldMut< #field_symbol, Value = #provider_type >
+        }
+    };
+
+    parse2(constraint)
+}

crates/cgp-component-macro-lib/src/getter_component/getter_field.rs

@@ -3,6 +3,16 @@ use syn::{Ident, Type};
 
 pub struct GetterField {
     pub field_name: Ident,
-    pub provider_type: Type,
+    pub field_type: Type,
+    pub return_type: Type,
     pub field_mut: Option<Mut>,
+    pub phantom_arg_type: Option<Type>,
+    pub field_mode: FieldMode,
+}
+
+pub enum FieldMode {
+    Reference,
+    OptionRef,
+    Str,
+    Clone,
 }

crates/cgp-component-macro-lib/src/getter_component/method.rs

@@ -0,0 +1,110 @@
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::Ident;
+
+use crate::getter_component::{FieldMode, GetterField};
+
+pub enum ContextArg {
+    SelfArg,
+    Ident(Ident),
+}
+
+pub fn derive_getter_method(
+    context_arg: &ContextArg,
+    spec: &GetterField,
+    phantom_generics: Option<TokenStream>,
+    provider_ident: Option<Ident>,
+) -> TokenStream {
+    let field_name = &spec.field_name;
+
+    let phantom_arg = match &spec.phantom_arg_type {
+        Some(phantom) => {
+            quote! {
+                , _phantom: PhantomData< #phantom >
+            }
+        }
+        None => TokenStream::new(),
+    };
+
+    let context_fn_arg = match &context_arg {
+        ContextArg::SelfArg => {
+            if spec.field_mut.is_none() {
+                quote! { &self }
+            } else {
+                quote! { &mut self }
+            }
+        }
+        ContextArg::Ident(context_type) => {
+            if spec.field_mut.is_none() {
+                quote! { context: & #context_type}
+            } else {
+                quote! { context: &mut #context_type }
+            }
+        }
+    };
+
+    let get_field_method = if spec.field_mut.is_none() {
+        quote! { get_field }
+    } else {
+        quote! { get_field_mut }
+    };
+
+    let context_var = match &context_arg {
+        ContextArg::SelfArg => {
+            quote! { self }
+        }
+        ContextArg::Ident(_) => {
+            quote! { context }
+        }
+    };
+
+    let call_expr = match provider_ident {
+        Some(provider_ident) => {
+            quote! {
+                #provider_ident :: #get_field_method ( #context_var, ::core::marker::PhantomData #phantom_generics )
+            }
+        }
+        None => {
+            quote! {
+                #context_var . #get_field_method ( ::core::marker::PhantomData #phantom_generics )
+            }
+        }
+    };
+
+    let call_expr = match spec.field_mode {
+        FieldMode::Reference => call_expr,
+        FieldMode::OptionRef => {
+            if spec.field_mut.is_none() {
+                quote! {
+                    #call_expr .as_ref()
+                }
+            } else {
+                quote! {
+                    #call_expr .as_mut()
+                }
+            }
+        }
+        FieldMode::Str => {
+            if spec.field_mut.is_none() {
+                quote! {
+                    #call_expr .as_str()
+                }
+            } else {
+                quote! {
+                    #call_expr .as_mut_str()
+                }
+            }
+        }
+        FieldMode::Clone => quote! {
+            #call_expr .clone()
+        },
+    };
+
+    let return_type = &spec.return_type;
+
+    quote! {
+        fn #field_name( #context_fn_arg #phantom_arg ) -> #return_type {
+            #call_expr
+        }
+    }
+}

crates/cgp-component-macro-lib/src/getter_component/mod.rs

@@ -1,13 +1,17 @@
 mod blanket;
+mod constraint;
 mod getter_field;
+mod method;
 mod parse;
 mod symbol;
 mod use_field;
 mod use_fields;
 mod with_provider;
 
 pub use blanket::*;
+pub use constraint::*;
 pub use getter_field::*;
+pub use method::*;
 pub use parse::*;
 pub use use_field::*;
 pub use use_fields::*;