Refactor macro implementation of #[cgp_impl] and #[cgp_provider]

crates/cgp-macro-core/src/exports.rs

@@ -5,8 +5,11 @@ export_constructs! {
     Cons,
     Chars,
     Symbol,
+    Index,
     PathCons,
     RedirectLookup,
     DelegateComponent,
     IsProviderFor,
+    HasField,
+    HasFieldMut,
 }

crates/cgp-macro-core/src/functions/field/mod.rs

@@ -0,0 +1,3 @@
+mod parse;
+
+pub use parse::*;

crates/cgp-macro-core/src/functions/field/parse.rs

@@ -0,0 +1,108 @@
+use quote::{ToTokens, quote};
+use syn::spanned::Spanned;
+use syn::token::Mut;
+use syn::{
+    Error, GenericArgument, PathArguments, PathSegment, Type, TypePath, parse_quote, parse2,
+};
+
+use crate::types::getter::FieldMode;
+
+pub fn parse_field_type(
+    return_type: &Type,
+    receiver_mut: &Option<Mut>,
+) -> syn::Result<(Type, FieldMode)> {
+    match &return_type {
+        Type::Reference(type_ref) => {
+            if type_ref.mutability.is_some() && receiver_mut.is_none() {
+                return Err(Error::new(
+                    type_ref.span(),
+                    format!(
+                        "&mut self is required for mutable field reference `{}`",
+                        type_ref.to_token_stream()
+                    ),
+                ));
+            }
+
+            if type_ref.elem.as_ref() == &parse_quote! { str } {
+                // Special case to handle &str as String field
+
+                let field_type: Type = parse_quote! { String };
+
+                Ok((field_type, FieldMode::Str))
+            } else if let (Type::Slice(slice), None) = (type_ref.elem.as_ref(), receiver_mut) {
+                let field_type = slice.elem.as_ref().clone();
+
+                Ok((field_type, FieldMode::Slice))
+            } else {
+                let field_type = type_ref.elem.as_ref().clone();
+
+                Ok((field_type, FieldMode::Reference))
+            }
+        }
+        Type::Path(type_path) => {
+            if let Some(field_type) = try_parse_option_ref(type_path) {
+                Ok((
+                    parse2(quote! { Option< #field_type > })?,
+                    FieldMode::OptionRef,
+                ))
+            } else if let (Some(field_type), None) = (try_parse_mref(type_path), receiver_mut) {
+                Ok((field_type.clone(), FieldMode::MRef))
+            } else {
+                Ok((return_type.clone(), FieldMode::Copy))
+            }
+        }
+        _ => Err(Error::new(
+            return_type.span(),
+            "return type must be a reference",
+        )),
+    }
+}
+
+fn try_parse_option_ref(type_path: &TypePath) -> Option<&Type> {
+    let segment = parse_single_segment_type_path(type_path).ok()?;
+
+    if segment.ident == "Option"
+        && let PathArguments::AngleBracketed(args) = &segment.arguments
+    {
+        let [arg] = Vec::from_iter(args.args.iter()).try_into().ok()?;
+
+        if let GenericArgument::Type(Type::Reference(type_ref)) = arg {
+            return Some(type_ref.elem.as_ref());
+        }
+    }
+
+    None
+}
+
+pub fn parse_single_segment_type_path(type_path: &TypePath) -> syn::Result<&PathSegment> {
+    let [segment]: [&PathSegment; 1] = type_path
+        .path
+        .segments
+        .iter()
+        .collect::<Vec<_>>()
+        .try_into()
+        .map_err(|_| {
+            Error::new(
+                type_path.span(),
+                "type path must contain exactly one path segment",
+            )
+        })?;
+
+    Ok(segment)
+}
+
+fn try_parse_mref(type_path: &TypePath) -> Option<&Type> {
+    let segment = parse_single_segment_type_path(type_path).ok()?;
+
+    if segment.ident == "MRef"
+        && let PathArguments::AngleBracketed(args) = &segment.arguments
+    {
+        let [arg1, arg2] = Vec::from_iter(args.args.iter()).try_into().ok()?;
+
+        if let (GenericArgument::Lifetime(_), GenericArgument::Type(ty)) = (arg1, arg2) {
+            return Some(ty);
+        }
+    }
+
+    None
+}

crates/cgp-macro-core/src/functions/generics/mod.rs

@@ -0,0 +1,3 @@
+mod merge_generics;
+
+pub use merge_generics::*;

crates/cgp-macro-core/src/functions/implicits/mod.rs

@@ -0,0 +1,3 @@
+mod parse;
+
+pub use parse::*;

crates/cgp-macro-lib/src/cgp_fn/parse_implicits.rs → crates/cgp-macro-core/src/functions/implicits/parse.rs

@@ -5,16 +5,16 @@ use syn::token::Comma;
 use syn::visit::{self, Visit};
 use syn::{Attribute, FnArg, Meta, Pat, PatIdent, PatType, Receiver};
 
-use crate::cgp_fn::ImplicitArgField;
-use crate::derive_getter::parse_field_type;
+use crate::functions::parse_field_type;
+use crate::types::implicits::{ImplicitArgField, ImplicitArgFields};
 
 pub fn extract_and_parse_implicit_args(
     args: &mut Punctuated<FnArg, Comma>,
-) -> syn::Result<Vec<ImplicitArgField>> {
+) -> syn::Result<ImplicitArgFields> {
     let implicit_fn_args = extract_implicit_args(args);
 
     if implicit_fn_args.is_empty() {
-        return Ok(Vec::new());
+        return Ok(ImplicitArgFields::default());
     }
 
     let Some(FnArg::Receiver(receiver)) = args.first() else {
@@ -38,7 +38,7 @@ pub fn extract_and_parse_implicit_args(
         implicit_args.push(spec);
     }
 
-    Ok(implicit_args)
+    Ok(ImplicitArgFields::new(implicit_args))
 }
 
 pub fn parse_implicit_arg(receiver: &Receiver, arg: &PatType) -> syn::Result<ImplicitArgField> {

crates/cgp-macro-core/src/functions/mod.rs

@@ -1,3 +1,9 @@
-mod merge_generics;
+mod field;
+mod generics;
+mod implicits;
+mod snake_case;
 
-pub use merge_generics::*;
+pub use field::*;
+pub use generics::*;
+pub use implicits::*;
+pub use snake_case::*;

crates/cgp-macro-lib/src/replace_self/snake_case.rs → crates/cgp-macro-core/src/functions/snake_case.rs

@@ -1,5 +1,3 @@
-use alloc::string::{String, ToString};
-
 use proc_macro2::Span;
 use syn::Ident;
 

crates/cgp-macro-core/src/lib.rs

@@ -5,3 +5,4 @@ pub mod functions;
 pub mod macros;
 pub mod traits;
 pub mod types;
+pub mod visitors;

crates/cgp-macro-core/src/traits/bounds.rs

@@ -0,0 +1,28 @@
+use syn::punctuated::Punctuated;
+use syn::token::Plus;
+use syn::{Generics, Type, TypeParamBound, parse_quote};
+
+pub trait ToTypeParamBounds {
+    fn to_type_param_bounds(&self) -> syn::Result<Punctuated<TypeParamBound, Plus>>;
+}
+
+pub trait AddTypeParamBounds {
+    fn add_type_param_bounds(&self, self_type: &Type, generics: &mut Generics) -> syn::Result<()>;
+}
+
+impl<T> AddTypeParamBounds for T
+where
+    T: ToTypeParamBounds,
+{
+    fn add_type_param_bounds(&self, self_type: &Type, generics: &mut Generics) -> syn::Result<()> {
+        let bounds = self.to_type_param_bounds()?;
+
+        if !bounds.is_empty() {
+            generics.make_where_clause().predicates.push(parse_quote! {
+                #self_type: #bounds
+            });
+        }
+
+        Ok(())
+    }
+}

crates/cgp-macro-core/src/traits/keyword.rs

@@ -1,6 +1,8 @@
 use syn::Ident;
 use syn::parse::ParseBuffer;
 
+use crate::types::keyword::Keyword;
+
 pub trait IsKeyword {
     const IDENT: &'static str;
 }
@@ -20,3 +22,19 @@ impl<'a> PeekKeyword for ParseBuffer<'a> {
         }
     }
 }
+
+pub trait ParseOptionalKeyword {
+    fn parse_optional_keyword<K: IsKeyword>(&self) -> syn::Result<Option<Keyword<K>>>;
+}
+
+impl<'a> ParseOptionalKeyword for ParseBuffer<'a> {
+    fn parse_optional_keyword<K: IsKeyword>(&self) -> syn::Result<Option<Keyword<K>>> {
+        let keyword = if self.peek_keyword::<K>() {
+            Some(self.parse()?)
+        } else {
+            None
+        };
+
+        Ok(keyword)
+    }
+}

crates/cgp-macro-core/src/traits/mod.rs

@@ -1,5 +1,7 @@
+mod bounds;
 mod keyword;
 mod to_type;
 
+pub use bounds::*;
 pub use keyword::*;
 pub use to_type::*;

crates/cgp-macro-core/src/types/attributes/function.rs

@@ -0,0 +1,72 @@
+use syn::punctuated::Punctuated;
+use syn::token::Comma;
+use syn::{Attribute, GenericParam, TypeParamBound, WherePredicate};
+
+use crate::types::attributes::{
+    UseProviderAttribute, UseProviderAttributes, UseTypeAttribute, UseTypeAttributes,
+};
+use crate::types::ident::IdentWithTypeArgs;
+
+#[derive(Default)]
+pub struct FunctionAttributes {
+    pub extend: Vec<TypeParamBound>,
+    pub extend_where: Vec<WherePredicate>,
+    pub uses: Vec<IdentWithTypeArgs>,
+    pub use_type: UseTypeAttributes,
+    pub use_provider: UseProviderAttributes,
+    pub impl_generics: Vec<GenericParam>,
+    pub raw_attributes: Vec<Attribute>,
+}
+
+impl FunctionAttributes {
+    pub fn parse(attributes: Vec<Attribute>) -> syn::Result<Self> {
+        let mut parsed_attributes = FunctionAttributes::default();
+
+        for attribute in attributes.into_iter() {
+            if let Some(ident) = attribute.path().get_ident() {
+                if ident == "extend" {
+                    let extend_bound = attribute
+                        .parse_args_with(Punctuated::<TypeParamBound, Comma>::parse_terminated)?;
+
+                    parsed_attributes.extend.extend(extend_bound);
+                } else if ident == "extend_where" {
+                    let where_predicates = attribute
+                        .parse_args_with(Punctuated::<WherePredicate, Comma>::parse_terminated)?;
+
+                    parsed_attributes.extend_where.extend(where_predicates);
+                } else if ident == "uses" {
+                    let uses = attribute.parse_args_with(
+                        Punctuated::<IdentWithTypeArgs, Comma>::parse_terminated,
+                    )?;
+
+                    parsed_attributes.uses.extend(uses);
+                } else if ident == "use_type" {
+                    let use_type = attribute
+                        .parse_args_with(Punctuated::<UseTypeAttribute, Comma>::parse_terminated)?;
+
+                    parsed_attributes.use_type.attributes.extend(use_type);
+                } else if ident == "use_provider" {
+                    let use_provider = attribute.parse_args_with(
+                        Punctuated::<UseProviderAttribute, Comma>::parse_terminated,
+                    )?;
+
+                    parsed_attributes
+                        .use_provider
+                        .attributes
+                        .extend(use_provider);
+                } else if ident == "impl_generics" {
+                    let impl_generics = attribute
+                        .parse_args_with(Punctuated::<GenericParam, Comma>::parse_terminated)?;
+
+                    parsed_attributes.impl_generics.extend(impl_generics);
+                } else {
+                    parsed_attributes.raw_attributes.push(attribute);
+                }
+            } else {
+                parsed_attributes.raw_attributes.push(attribute);
+            }
+        }
+
+        Ok(parsed_attributes)
+    }
+}

crates/cgp-macro-core/src/types/attributes/impl_attributes.rs

@@ -0,0 +1,61 @@
+use syn::Attribute;
+use syn::punctuated::Punctuated;
+use syn::token::Comma;
+
+use crate::types::attributes::{
+    UseProviderAttribute, UseProviderAttributes, UseTypeAttribute, UseTypeAttributes,
+    UsesAttributes,
+};
+use crate::types::ident::IdentWithTypeArgs;
+
+#[derive(Default)]
+pub struct ImplAttributes {
+    pub uses: UsesAttributes,
+    pub use_type: UseTypeAttributes,
+    pub use_provider: UseProviderAttributes,
+    pub raw_attributes: Vec<Attribute>,
+}
+
+impl ImplAttributes {
+    pub fn parse(attributes: &Vec<Attribute>) -> syn::Result<ImplAttributes> {
+        let mut parsed_attributes = ImplAttributes::default();
+
+        for attribute in attributes {
+            if let Some(ident) = attribute.path().get_ident() {
+                match ident.to_string().as_ref() {
+                    "uses" => {
+                        let uses = attribute.parse_args_with(
+                            Punctuated::<IdentWithTypeArgs, Comma>::parse_terminated,
+                        )?;
+
+                        parsed_attributes.uses.imports.extend(uses);
+                    }
+                    "use_type" => {
+                        let use_type = attribute.parse_args_with(
+                            Punctuated::<UseTypeAttribute, Comma>::parse_terminated,
+                        )?;
+
+                        parsed_attributes.use_type.attributes.extend(use_type);
+                    }
+                    "use_provider" => {
+                        let use_provider = attribute.parse_args_with(
+                            Punctuated::<UseProviderAttribute, Comma>::parse_terminated,
+                        )?;
+
+                        parsed_attributes
+                            .use_provider
+                            .attributes
+                            .extend(use_provider);
+                    }
+                    _ => {
+                        parsed_attributes.raw_attributes.push(attribute.clone());
+                    }
+                };
+            } else {
+                parsed_attributes.raw_attributes.push(attribute.clone());
+            }
+        }
+
+        Ok(parsed_attributes)
+    }
+}

crates/cgp-macro-core/src/types/attributes/mod.rs

@@ -0,0 +1,11 @@
+mod function;
+mod impl_attributes;
+mod use_provider;
+mod use_type;
+mod uses;
+
+pub use function::*;
+pub use impl_attributes::*;
+pub use use_provider::*;
+pub use use_type::*;
+pub use uses::*;