Support #[use_provider] inside #[cgp_fn]

crates/cgp-macro-lib/src/cgp_fn/attributes.rs

@@ -5,6 +5,7 @@ use syn::token::Comma;
 use syn::{Attribute, TypeParamBound, WherePredicate};
 
 use crate::cgp_fn::{FunctionAttributes, UseTypeSpec};
+use crate::cgp_impl::UseProviderSpec;
 use crate::parse::SimpleType;
 
 pub fn parse_function_attributes(
@@ -32,6 +33,10 @@ pub fn parse_function_attributes(
                 let use_type = attribute
                     .parse_args_with(Punctuated::<UseTypeSpec, Comma>::parse_terminated)?;
                 parsed_attributes.use_type.extend(use_type);
+            } else if ident == "use_provider" {
+                let use_provider = attribute
+                    .parse_args_with(Punctuated::<UseProviderSpec, Comma>::parse_terminated)?;
+                parsed_attributes.use_provider.extend(use_provider);
             } else {
                 attributes.push(attribute);
             }

crates/cgp-macro-lib/src/cgp_fn/item_impl.rs

@@ -1,12 +1,13 @@
 use quote::quote;
 use syn::punctuated::Punctuated;
 use syn::token::Plus;
-use syn::{Generics, Ident, ItemFn, ItemImpl, TypeParamBound, parse2};
+use syn::{Generics, Ident, ItemFn, ItemImpl, TypeParamBound, parse_quote, parse2};
 
 use crate::cgp_fn::{
     FunctionAttributes, ImplicitArgField, apply_use_type_attributes_to_item_impl,
     build_implicit_args_bounds,
 };
+use crate::cgp_impl::derive_provider_bounds;
 
 pub fn derive_item_impl(
     trait_ident: &Ident,
@@ -69,5 +70,14 @@ pub fn derive_item_impl(
         item_impl = apply_use_type_attributes_to_item_impl(&item_impl, &attributes.use_type)?;
     }
 
+    if !attributes.use_provider.is_empty() {
+        let where_clause = item_impl.generics.make_where_clause();
+
+        for spec in attributes.use_provider.iter() {
+            let provider_bounds = derive_provider_bounds(&parse_quote! { Self }, spec)?;
+            where_clause.predicates.push(provider_bounds);
+        }
+    }
+
     Ok(item_impl)
 }

crates/cgp-macro-lib/src/cgp_fn/spec.rs

@@ -2,6 +2,7 @@ use syn::token::Mut;
 use syn::{Ident, Type, TypeParamBound, WherePredicate};
 
 use crate::cgp_fn::UseTypeSpec;
+use crate::cgp_impl::UseProviderSpec;
 use crate::derive_getter::FieldMode;
 use crate::parse::SimpleType;
 
@@ -20,4 +21,5 @@ pub struct FunctionAttributes {
     pub extend_where: Vec<WherePredicate>,
     pub uses: Vec<SimpleType>,
     pub use_type: Vec<UseTypeSpec>,
+    pub use_provider: Vec<UseProviderSpec>,
 }

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

@@ -8,7 +8,6 @@ use syn::{Error, ItemImpl, TypeParamBound, parse_quote, parse2};
 use crate::cgp_fn::{apply_use_type_attributes_to_item_impl, build_implicit_args_bounds};
 use crate::cgp_impl::attributes::parse_impl_attributes;
 use crate::cgp_impl::provider_bounds::derive_provider_bounds;
-use crate::cgp_impl::provider_call::transform_provider_call;
 use crate::cgp_impl::{ImplProviderSpec, derive_provider_impl, implicit_args};
 use crate::derive_provider::{
     derive_component_name_from_provider_impl, derive_is_provider_for, derive_provider_struct,
@@ -58,8 +57,6 @@ pub fn derive_cgp_impl(
             let provider_bounds = derive_provider_bounds(&parse_quote! { Self }, spec)?;
             where_clause.predicates.push(provider_bounds);
         }
-
-        transform_provider_call(&mut item_impl)?;
     }
 
     if spec.provider_type == parse_quote! { Self } {

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

@@ -2,13 +2,14 @@ mod attributes;
 mod derive;
 mod implicit_args;
 mod provider_bounds;
-mod provider_call;
 mod provider_impl;
 mod spec;
 mod transform;
 mod use_provider;
 
 pub use derive::*;
+pub use provider_bounds::*;
 pub use provider_impl::*;
 pub use spec::*;
 pub use transform::*;
+pub use use_provider::*;

crates/cgp-tests/tests/cgp_fn_tests/mod.rs

@@ -8,6 +8,7 @@ pub mod multi;
 pub mod mutable;
 pub mod nested_foreign_type;
 pub mod type_equality;
+pub mod use_provider;
 pub mod use_type;
 pub mod use_type_alias;
 pub mod uses;

crates/cgp-tests/tests/cgp_fn_tests/use_provider.rs

@@ -0,0 +1,35 @@
+use cgp::prelude::*;
+
+#[cgp_component(AreaCalculator)]
+pub trait CanCalculateArea {
+    fn area(&self) -> f64;
+}
+
+#[cgp_impl(new RectangleAreaCalculator)]
+impl AreaCalculator {
+    fn area(&self, #[implicit] width: f64, #[implicit] height: f64) -> f64 {
+        width * height
+    }
+}
+
+#[cgp_fn]
+#[use_provider(RectangleAreaCalculator: AreaCalculator)]
+fn rectangle_area(&self) -> f64 {
+    RectangleAreaCalculator::area(self)
+}
+
+#[derive(HasField)]
+pub struct Rectangle {
+    pub width: f64,
+    pub height: f64,
+}
+
+#[test]
+fn test_use_provider() {
+    let rectangle = Rectangle {
+        width: 3.0,
+        height: 4.0,
+    };
+
+    assert_eq!(rectangle.rectangle_area(), 12.0);
+}

crates/cgp-tests/tests/component_tests/cgp_impl/impl_self.rs

@@ -22,7 +22,6 @@ pub struct Rectangle {
 #[use_provider(RectangleArea: AreaCalculator)]
 impl CanCalculateArea for Rectangle {
     fn area(&self) -> f64 {
-        #[use_provider(RectangleArea)]
-        self.area()
+        RectangleArea::area(self)
     }
 }

crates/cgp-tests/tests/component_tests/cgp_impl/use_provider.rs

@@ -16,10 +16,7 @@ impl AreaCalculator {
 #[use_provider(Inner: AreaCalculator)]
 impl<Inner> AreaCalculator {
     fn area(&self, #[implicit] scale_factor: f64) -> f64 {
-        let base_area = #[use_provider(Inner)]
-        self.area();
-
-        base_area * scale_factor * scale_factor
+        Inner::area(self) * scale_factor * scale_factor
     }
 }