Implement namespace statement for delegate_components!

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

@@ -1,10 +1,6 @@
-mod attributes;
 mod define_struct;
-mod derive_namespace;
 mod impl_delegate;
 mod merge_generics;
 
-pub use attributes::*;
 pub use define_struct::*;
-pub use derive_namespace::*;
 pub use impl_delegate::*;

crates/cgp-macro-lib/src/entrypoints/delegate_components.rs

@@ -2,10 +2,7 @@ use proc_macro2::TokenStream;
 use quote::ToTokens;
 use syn::parse2;
 
-use crate::delegate_components::{
-    DelegateNamespaceAttribute, define_struct, derive_namespace_delegate, impl_delegate_components,
-    parse_delegate_attributes,
-};
+use crate::delegate_components::{define_struct, impl_delegate_components};
 use crate::parse::{DelegateComponents, SimpleType, TypeGenerics};
 
 pub fn delegate_components(body: TokenStream) -> syn::Result<TokenStream> {
@@ -26,15 +23,6 @@ pub fn delegate_components(body: TokenStream) -> syn::Result<TokenStream> {
         output.extend(component_struct.to_token_stream());
     }
 
-    let attributes = parse_delegate_attributes(spec.attributes)?;
-
-    if let Some(DelegateNamespaceAttribute { namespace }) = attributes.use_namespace {
-        let namespace_impl =
-            derive_namespace_delegate(namespace, target_type, &target_generics.generics)?;
-
-        output.extend(namespace_impl);
-    }
-
     let impl_items = impl_delegate_components(target_type, target_generics, &spec.entries)?;
 
     output.extend(impl_items);

crates/cgp-macro-lib/src/parse/delegate_components.rs

@@ -5,13 +5,12 @@ use quote::{ToTokens, TokenStreamExt, quote};
 use syn::parse::discouraged::Speculative;
 use syn::parse::{Parse, ParseStream};
 use syn::punctuated::Punctuated;
-use syn::token::{At, Bracket, Colon, Comma, Gt, Lt, Pound, RArrow, Semi};
-use syn::{Attribute, Error, Generics, Ident, Token, Type, braced, bracketed, parse_quote, parse2};
+use syn::token::{At, Bracket, Colon, Comma, Gt, Lt, RArrow, Semi};
+use syn::{Error, Generics, Ident, Token, Type, braced, bracketed, parse_quote, parse2};
 
 use crate::parse::{ComponentPaths, ImplGenerics, SimpleType, TypeGenerics};
 
 pub struct DelegateComponents {
-    pub attributes: Vec<Attribute>,
     pub new_struct: bool,
     pub target_type: Type,
     pub target_generics: ImplGenerics,
@@ -73,12 +72,6 @@ impl DelegateValue {
 
 impl Parse for DelegateComponents {
     fn parse(input: ParseStream) -> syn::Result<Self> {
-        let attributes = if input.peek(Pound) {
-            input.call(Attribute::parse_outer)?
-        } else {
-            Vec::new()
-        };
-
         let target_generics = if input.peek(Lt) {
             input.parse()?
         } else {
@@ -110,7 +103,6 @@ impl Parse for DelegateComponents {
         let entries = meta_entries.into_iter().chain(delegate_entries).collect();
 
         Ok(Self {
-            attributes,
             new_struct,
             target_type,
             target_generics,
@@ -153,6 +145,40 @@ pub fn parse_meta_delegate_entries(
 
                 entries.push(entry)
             }
+        } else if keyword == "namespace" {
+            input.advance_to(&fork);
+
+            let ident: Ident = input.parse()?;
+            let _: Semi = input.parse()?;
+
+            let namespace_ident = if ident == "default" {
+                Ident::new("DefaultNamespace", ident.span())
+            } else {
+                ident
+            };
+
+            let delegate_key: Type = parse2(quote! {
+                __Component__
+            })?;
+
+            let generics: ImplGenerics = parse2(quote! {
+                <__Component__: #namespace_ident< #target_type >>
+            })?;
+
+            let delegate_value: Type = parse2(quote! {
+                < __Component__ as #namespace_ident< #target_type >>::Provider
+            })?;
+
+            let entry = DelegateEntry {
+                keys: Punctuated::from_iter([DelegateKey {
+                    ty: delegate_key,
+                    generics,
+                }]),
+                mode: DelegateMode::Provider(Colon(Span::call_site())),
+                value: DelegateValue::Type(delegate_value),
+            };
+
+            entries.push(entry)
         } else {
             break;
         }

crates/cgp-macro-lib/src/parse/path.rs

@@ -137,6 +137,7 @@ pub fn path_type_as_ident(path_type: &Type) -> Option<Ident> {
         let path_str = path_ident.to_string();
         if let Some(path_char) = path_str.chars().next()
             && path_char.is_ascii_lowercase()
+            && !is_primitive_type(&path_str)
         {
             return Some(path_ident);
         }
@@ -166,3 +167,17 @@ impl Parse for PathType {
         }
     }
 }
+
+pub fn is_primitive_type(ident: &str) -> bool {
+    if (ident.starts_with("i") || ident.starts_with("u") || ident.starts_with("f"))
+        && ident[1..].chars().all(|c| c.is_numeric())
+    {
+        return true;
+    }
+
+    if ["char", "bool", "usize", "isize", "str"].contains(&ident) {
+        return true;
+    }
+
+    false
+}

crates/cgp-tests/tests/namespace_tests/namespace_macro/basic.rs

@@ -34,8 +34,9 @@ impl BarProvider {
 pub struct App;
 
 delegate_components! {
-    #[use_namespace(MyNamespace)]
     App {
+        namespace MyNamespace;
+
         @MyFooComponent:
             DummyFoo,
         @MyBarComponent:

crates/cgp-tests/tests/namespace_tests/namespace_macro/extended_namespace.rs

@@ -7,8 +7,9 @@ use cgp_tests::namespaces::ExtendedNamespace;
 pub struct App;
 
 delegate_components! {
-    #[use_namespace(ExtendedNamespace)]
     App {
+        namespace ExtendedNamespace;
+
         @app.ErrorTypeProviderComponent:
             UseType<String>,
         @app.{

crates/cgp-tests/tests/namespace_tests/namespace_macro/multi_namespace.rs

@@ -45,8 +45,9 @@ impl BarProvider {
 pub struct App;
 
 delegate_components! {
-    #[use_namespace(MyNamespace)]
     App {
+        namespace MyNamespace;
+
         @MyApp.MyFooComponent:
             DummyFoo,
         @MyApp.MyBarComponent:
@@ -64,8 +65,9 @@ check_components! {
 pub struct OtherApp;
 
 delegate_components! {
-    #[use_namespace(OtherNamespace)]
     OtherApp {
+        namespace OtherNamespace;
+
         @my_app.MyFooComponent:
             DummyFoo,
         @my_app.MyBarComponent:

crates/cgp-tests/tests/namespace_tests/namespace_macro/symbol_path.rs

@@ -35,8 +35,9 @@ impl BarProvider {
 pub struct App;
 
 delegate_components! {
-    #[use_namespace(MyNamespace)]
     App {
+        namespace MyNamespace;
+
         @my_app.MyFooComponent:
             DummyFoo,
         @my_app.MyBarComponent:

crates/cgp-tests/tests/namespace_tests/namespace_macro/type_path.rs

@@ -37,8 +37,9 @@ impl BarProvider {
 pub struct App;
 
 delegate_components! {
-    #[use_namespace(MyNamespace)]
     App {
+        namespace MyNamespace;
+
         @MyApp.MyFooComponent:
             DummyFoo,
         @MyApp.MyBarComponent:

crates/cgp-tests/tests/namespace_tests/open.rs

@@ -1,23 +1,48 @@
-use cgp::core::error::{ErrorRaiserComponent, ErrorTypeProviderComponent};
-use cgp::extra::error::ReturnError;
 use cgp::prelude::*;
 
 pub struct App;
 
+#[cgp_component(FooProvider)]
+pub trait Foo<T> {
+    fn foo(&self, value: &T);
+}
+
+#[cgp_component(BarProvider)]
+pub trait Bar<T> {
+    fn bar(&self, value: &T);
+}
+
+#[cgp_impl(new DummyFoo)]
+impl<T> FooProvider<T> {
+    fn foo(&self, _value: &T) {}
+}
+
+#[cgp_impl(new DummyBar)]
+impl<T> BarProvider<T> {
+    fn bar(&self, _value: &T) {}
+}
+
 delegate_components! {
     App {
-        open ErrorRaiserComponent;
+        open FooProviderComponent, BarProviderComponent;
 
-        ErrorTypeProviderComponent:
-            UseType<String>,
-        @ErrorRaiserComponent.String:
-            ReturnError,
+        @FooProviderComponent.String:
+            DummyFoo,
+        @BarProviderComponent.{u32, u64, bool, usize, isize}:
+            DummyBar,
     }
 }
 
 check_components! {
     App {
-        ErrorRaiserComponent:
+        FooProviderComponent:
             String,
+        BarProviderComponent: [
+            u32,
+            u64,
+            bool,
+            usize,
+            isize,
+        ],
     }
 }

crates/cgp-tests/tests/namespace_tests/redirect.rs

@@ -18,8 +18,9 @@ impl FooProvider {
 pub struct App;
 
 delegate_components! {
-    #[use_namespace]
     App {
+        namespace default;
+
         // @bar: TestProvider,
 
         @bar.baz: TestProvider,

crates/cgp-tests/tests/namespace_tests/use_namespace.rs

@@ -13,8 +13,9 @@ pub trait Foo {
 pub struct App;
 
 delegate_components! {
-    #[use_namespace]
     App {
+        namespace default;
+
         @cgp.core.error.ErrorTypeProviderComponent:
             UseType<String>,
         @cgp.core.error.ErrorRaiserComponent.String: