Implement ItemCgpFn (#234)

Author: soareschen

Cargo.lock

@@ -18,4 +18,4 @@ default = []
 syn             = { version = "2.0.95", features = [ "full", "extra-traits" ] }
 quote           = "1.0.38"
 proc-macro2     = "1.0.92"
-cgp-macro-lib   = { workspace = true }
+cgp-macro-core  = { workspace = true }

crates/macros/cgp-extra-macro-lib/Cargo.toml

@@ -1,6 +1,6 @@
 use std::collections::BTreeSet;
 
-use cgp_macro_lib::utils::to_camel_case_str;
+use cgp_macro_core::functions::to_camel_case_str;
 use proc_macro2::{Span, TokenStream};
 use quote::quote;
 use syn::punctuated::Punctuated;

crates/macros/cgp-extra-macro-lib/src/entrypoints/cgp_auto_dispatch.rs

@@ -1,4 +1,4 @@
-use cgp_macro_lib::utils::to_camel_case_str;
+use cgp_macro_core::functions::to_camel_case_str;
 use proc_macro2::TokenStream;
 use quote::{ToTokens, quote};
 use syn::punctuated::Punctuated;

crates/macros/cgp-extra-macro-lib/src/entrypoints/cgp_computer.rs

@@ -1,4 +1,4 @@
-use cgp_macro_lib::utils::to_camel_case_str;
+use cgp_macro_core::functions::to_camel_case_str;
 use proc_macro2::TokenStream;
 use quote::quote;
 use syn::spanned::Spanned;

crates/macros/cgp-extra-macro-lib/src/entrypoints/cgp_producer.rs

@@ -1,3 +1,4 @@
+mod camel_case;
 mod delegated_impls;
 mod field;
 mod generics;
@@ -6,6 +7,7 @@ mod implicits;
 mod is_provider_params;
 mod snake_case;
 
+pub use camel_case::*;
 pub use delegated_impls::*;
 pub use field::*;
 pub use generics::*;

…macros/cgp-macro-lib/src/utils/string.rs …p-macro-core/src/functions/camel_case.rscrates/macros/cgp-macro-lib/src/utils/string.rs renamed to crates/macros/cgp-macro-core/src/functions/camel_case.rs crates/macros/cgp-macro-lib/src/utils/string.rs renamed to crates/macros/cgp-macro-core/src/functions/camel_case.rs

@@ -0,0 +1,42 @@
+use syn::{Ident, ItemFn, Visibility};
+
+use crate::functions::{extract_and_parse_implicit_args, to_camel_case_str};
+use crate::types::attributes::FunctionAttributes;
+use crate::types::cgp_fn::PreprocessedItemCgpFn;
+
+pub struct ItemCgpFn {
+    pub ident: Option<Ident>,
+    pub item_fn: ItemFn,
+}
+
+impl ItemCgpFn {
+    pub fn preprocess(&self) -> syn::Result<PreprocessedItemCgpFn> {
+        let mut item_fn = self.item_fn.clone();
+
+        let ident = self.ident.clone().unwrap_or_else(|| {
+            Ident::new(
+                &to_camel_case_str(&item_fn.sig.ident.to_string()),
+                item_fn.sig.ident.span(),
+            )
+        });
+
+        let visibility = item_fn.vis.clone();
+        item_fn.vis = Visibility::Inherited;
+
+        let implicit_args = extract_and_parse_implicit_args(&mut item_fn.sig.inputs)?;
+        implicit_args.prepend_to_block(&mut item_fn.block)?;
+
+        let attributes = FunctionAttributes::parse(core::mem::take(&mut item_fn.attrs))?;
+
+        let generics = core::mem::take(&mut item_fn.sig.generics);
+
+        Ok(PreprocessedItemCgpFn {
+            ident,
+            item_fn,
+            implicit_args,
+            attributes,
+            visibility,
+            generics,
+        })
+    }
+}

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

@@ -0,0 +1,5 @@
+mod item;
+mod preprocessed;
+
+pub use item::*;
+pub use preprocessed::*;

crates/macros/cgp-macro-core/src/types/cgp_fn/item.rs

@@ -0,0 +1,143 @@
+use quote::quote;
+use syn::punctuated::Punctuated;
+use syn::token::Plus;
+use syn::{
+    Generics, Ident, Item, ItemFn, ItemImpl, ItemTrait, TraitItemFn, Type, TypeParamBound,
+    Visibility, parse_quote, parse2,
+};
+
+use crate::traits::AddTypeParamBounds;
+use crate::types::attributes::FunctionAttributes;
+use crate::types::implicits::ImplicitArgFields;
+
+pub struct PreprocessedItemCgpFn {
+    pub ident: Ident,
+    pub item_fn: ItemFn,
+    pub implicit_args: ImplicitArgFields,
+    pub attributes: FunctionAttributes,
+    pub visibility: Visibility,
+    pub generics: Generics,
+}
+
+impl PreprocessedItemCgpFn {
+    pub fn to_items(&self) -> syn::Result<Vec<Item>> {
+        let item_trait = self.to_item_trait()?;
+        let item_impl = self.to_item_impl()?;
+
+        Ok(vec![item_trait.into(), item_impl.into()])
+    }
+
+    pub fn to_item_trait(&self) -> syn::Result<ItemTrait> {
+        let Self {
+            ident,
+            item_fn,
+            attributes,
+            generics,
+            visibility,
+            ..
+        } = self;
+
+        let trait_item_fn = TraitItemFn {
+            attrs: item_fn.attrs.clone(),
+            sig: item_fn.sig.clone(),
+            default: None,
+            semi_token: None,
+        };
+
+        let mut item_trait: ItemTrait = parse2(quote! {
+            pub trait #ident {
+                #trait_item_fn
+            }
+        })?;
+
+        item_trait.generics = generics.clone();
+        item_trait.generics.where_clause = None;
+
+        item_trait.supertraits.extend(attributes.extend.clone());
+
+        if !attributes.extend_where.is_empty() {
+            item_trait
+                .generics
+                .make_where_clause()
+                .predicates
+                .extend(attributes.extend_where.clone());
+        }
+
+        attributes.use_type.transform_item_trait(&mut item_trait)?;
+
+        item_trait.attrs.extend(attributes.raw_attributes.clone());
+        item_trait.vis = visibility.clone();
+
+        Ok(item_trait)
+    }
+
+    pub fn to_item_impl(&self) -> syn::Result<ItemImpl> {
+        let Self {
+            ident,
+            item_fn,
+            implicit_args,
+            attributes,
+            generics,
+            ..
+        } = self;
+
+        let type_generics = generics.split_for_impl().1;
+
+        let self_type: Type = parse_quote!(Self);
+
+        let mut item_impl: ItemImpl = parse2(quote! {
+            impl #ident #type_generics for __Context__ {
+                #item_fn
+            }
+        })?;
+
+        item_impl.generics = generics.clone();
+        item_impl
+            .generics
+            .params
+            .insert(0, parse_quote!(__Context__));
+
+        item_impl
+            .generics
+            .params
+            .extend(attributes.impl_generics.clone());
+
+        {
+            let mut bounds: Punctuated<TypeParamBound, Plus> = Punctuated::default();
+            bounds.extend(attributes.extend.clone());
+
+            for import in attributes.uses.iter() {
+                bounds.push(parse2(quote! { #import })?);
+            }
+
+            if !bounds.is_empty() {
+                item_impl
+                    .generics
+                    .make_where_clause()
+                    .predicates
+                    .push(parse2(quote! {
+                        Self: #bounds
+                    })?);
+            }
+        }
+
+        if !attributes.extend_where.is_empty() {
+            item_impl
+                .generics
+                .make_where_clause()
+                .predicates
+                .extend(attributes.extend_where.clone());
+        }
+
+        implicit_args.add_type_param_bounds(&self_type, &mut item_impl.generics)?;
+
+        attributes.use_type.transform_item_impl(&mut item_impl)?;
+        attributes
+            .use_provider
+            .add_type_param_bounds(&self_type, &mut item_impl.generics)?;
+
+        item_impl.attrs.extend(attributes.raw_attributes.clone());
+
+        Ok(item_impl)
+    }
+}