3 files changed, 49 insertions, 7 deletions

diff --git a/mingling_macros/src/chain.rs b/mingling_macros/src/chain.rs
index a7be233..9ef4ae0 100644
--- a/mingling_macros/src/chain.rs
+++ b/mingling_macros/src/chain.rs
@@ -125,10 +125,18 @@ pub fn chain_attr(item: TokenStream) -> TokenStream {
     let chain_entry = quote! {
         #struct_name => #previous_type,
     };
+    let chain_exist_entry = quote! {
+        id if id == std::any::TypeId::of::<#previous_type>() => true,
+    };
     let mut chains = crate::CHAINS.lock().unwrap();
-    let entry = chain_entry.to_string();
-    if !chains.contains(&entry) {
-        chains.push(entry);
+    let mut chain_exist = crate::CHAINS_EXIST.lock().unwrap();
+    let chain_entry = chain_entry.to_string();
+    let chain_exist_entry = chain_exist_entry.to_string();
+    if !chains.contains(&chain_entry) {
+        chains.push(chain_entry);
+    }
+    if !chains.contains(&chain_exist_entry) {
+        chain_exist.push(chain_exist_entry);
     }
 
     expanded.into()
diff --git a/mingling_macros/src/lib.rs b/mingling_macros/src/lib.rs
index 26a7381..821743e 100644
--- a/mingling_macros/src/lib.rs
+++ b/mingling_macros/src/lib.rs
@@ -21,6 +21,8 @@ use std::sync::Mutex;
 // Global variable declarations for storing chain and renderer mappings
 pub(crate) static CHAINS: Lazy<Mutex<Vec<String>>> = Lazy::new(|| Mutex::new(Vec::new()));
 pub(crate) static RENDERERS: Lazy<Mutex<Vec<String>>> = Lazy::new(|| Mutex::new(Vec::new()));
+pub(crate) static CHAINS_EXIST: Lazy<Mutex<Vec<String>>> = Lazy::new(|| Mutex::new(Vec::new()));
+pub(crate) static RENDERERS_EXIST: Lazy<Mutex<Vec<String>>> = Lazy::new(|| Mutex::new(Vec::new()));
 
 /// Creates a command node from a dot-separated path string.
 ///
@@ -66,7 +68,7 @@ pub fn chain_struct(input: TokenStream) -> TokenStream {
 }
 
 #[proc_macro]
-pub fn dispatcher_chain(input: TokenStream) -> TokenStream {
+pub fn dispatcher(input: TokenStream) -> TokenStream {
     dispatcher_chain::dispatcher_chain(input)
 }
 
@@ -207,6 +209,8 @@ pub fn program(input: TokenStream) -> TokenStream {
 
     let renderers = RENDERERS.lock().unwrap().clone();
     let chains = CHAINS.lock().unwrap().clone();
+    let renderer_exist = RENDERERS_EXIST.lock().unwrap().clone();
+    let chain_exist = CHAINS_EXIST.lock().unwrap().clone();
 
     let renderer_tokens: Vec<proc_macro2::TokenStream> = renderers
         .iter()
@@ -218,6 +222,16 @@ pub fn program(input: TokenStream) -> TokenStream {
         .map(|s| syn::parse_str::<proc_macro2::TokenStream>(s).unwrap())
         .collect();
 
+    let renderer_exist_tokens: Vec<proc_macro2::TokenStream> = renderer_exist
+        .iter()
+        .map(|s| syn::parse_str::<proc_macro2::TokenStream>(s).unwrap())
+        .collect();
+
+    let chain_exist_tokens: Vec<proc_macro2::TokenStream> = chain_exist
+        .iter()
+        .map(|s| syn::parse_str::<proc_macro2::TokenStream>(s).unwrap())
+        .collect();
+
     let expanded = quote! {
         pub struct #name;
 
@@ -228,6 +242,18 @@ pub fn program(input: TokenStream) -> TokenStream {
             ::mingling::__dispatch_program_chains!(
                 #(#chain_tokens)*
             );
+            fn has_renderer(any: &::mingling::AnyOutput) -> bool {
+                match any.type_id {
+                    #(#renderer_exist_tokens)*
+                    _ => false
+                }
+            }
+            fn has_chain(any: &::mingling::AnyOutput) -> bool {
+                match any.type_id {
+                    #(#chain_exist_tokens)*
+                    _ => false
+                }
+            }
         }
 
         impl #name {
diff --git a/mingling_macros/src/renderer.rs b/mingling_macros/src/renderer.rs
index 54a2526..de244c0 100644
--- a/mingling_macros/src/renderer.rs
+++ b/mingling_macros/src/renderer.rs
@@ -104,11 +104,19 @@ pub fn renderer_attr(item: TokenStream) -> TokenStream {
     let renderer_entry = quote! {
         #struct_name => #previous_type,
     };
+    let renderer_exist_entry = quote! {
+        id if id == std::any::TypeId::of::<#previous_type>() => true,
+    };
 
     let mut renderers = crate::RENDERERS.lock().unwrap();
-    let entry_str = renderer_entry.to_string();
-    if !renderers.contains(&entry_str) {
-        renderers.push(entry_str);
+    let mut renderer_exist = crate::RENDERERS_EXIST.lock().unwrap();
+    let renderer_entry_str = renderer_entry.to_string();
+    let renderer_exist_entry_str = renderer_exist_entry.to_string();
+    if !renderers.contains(&renderer_entry_str) {
+        renderers.push(renderer_entry_str);
+    }
+    if !renderer_exist.contains(&renderer_exist_entry_str) {
+        renderer_exist.push(renderer_exist_entry_str);
     }
 
     // Generate the struct and implementation