1 files changed, 16 insertions, 51 deletions

diff --git a/mingling_macros/src/renderer.rs b/mingling_macros/src/renderer.rs
index 880c50f..d124ec9 100644
--- a/mingling_macros/src/renderer.rs
+++ b/mingling_macros/src/renderer.rs
@@ -1,22 +1,15 @@
 use proc_macro::TokenStream;
 use quote::{ToTokens, quote};
 use syn::spanned::Spanned;
-use syn::{ItemFn, ReturnType, Signature, Type, TypePath, parse_macro_input};
+use syn::{ItemFn, ReturnType, Signature, TypePath, parse_macro_input};
 
 use crate::get_global_set;
 use crate::res_injection::{extract_args_info, generate_immut_resource_bindings};
 
-/// Extracts and returns the return type from the function signature (or None for `()` / no return type).
-fn extract_return_type(sig: &Signature) -> Option<syn::Type> {
+/// Extracts the user's return type, returning `None` for no return type.
+fn extract_user_return_type(sig: &Signature) -> Option<proc_macro2::TokenStream> {
     match &sig.output {
-        ReturnType::Type(_, ty) => {
-            match &**ty {
-                // `()` means no custom return type
-                Type::Tuple(tuple) if tuple.elems.is_empty() => None,
-                // Any other return type is allowed
-                custom_ty => Some((*custom_ty).clone()),
-            }
-        }
+        ReturnType::Type(_, ty) => Some(quote! { #ty }),
         ReturnType::Default => None,
     }
 }
@@ -44,8 +37,8 @@ pub fn renderer_attr(attr: TokenStream, item: TokenStream) -> TokenStream {
         Err(e) => return e.to_compile_error().into(),
     };
 
-    // Validate return type – now returns Some(type) if custom type, None if ()
-    let return_type = extract_return_type(&input_fn.sig);
+    // Determine the user's return type and whether it needs to be converted to RenderResult
+    let user_return_type = extract_user_return_type(&input_fn.sig);
 
     // Get function body statements
     let fn_body_stmts: Vec<syn::Stmt> = input_fn.block.stmts.clone();
@@ -76,23 +69,6 @@ pub fn renderer_attr(attr: TokenStream, item: TokenStream) -> TokenStream {
     let immut_resource_stmts = generate_immut_resource_bindings(resources.iter(), program_type);
     let mut_resources: Vec<_> = resources.iter().filter(|r| r.is_mut).collect();
 
-    // Determine public return type and the expression to return dummy_r
-    let (public_return_type, result_return) = if let Some(custom_ty) = &return_type {
-        // User specified a custom return type (e.g. -> String)
-        let ret_ty = quote! { #custom_ty };
-        let expr = quote! { dummy_r.into() };
-        (ret_ty, expr)
-    } else {
-        // Return type is () — no custom return type specified
-        let ret_ty = quote! { () };
-        let expr = quote! {
-            if !dummy_r.is_empty() {
-                ::std::println!("{}", &*dummy_r);
-            }
-        };
-        (ret_ty, expr)
-    };
-
     let inner_body_with_resources = if has_mut_resources {
         let mut wrapped = quote! { #(#fn_body_stmts)* };
         for res in mut_resources.iter().rev() {
@@ -110,8 +86,7 @@ pub fn renderer_attr(attr: TokenStream, item: TokenStream) -> TokenStream {
     };
 
     // Build the Renderer::render body with resource injection
-    // Renderer::render returns (), output goes through __renderer_inner_result parameter.
-    // Resources are injected from the program context here.
+    // The user's body now directly creates and returns a RenderResult.
     let render_fn_body = if has_resources {
         quote! {
             #(#immut_resource_stmts)*
@@ -121,22 +96,10 @@ pub fn renderer_attr(attr: TokenStream, item: TokenStream) -> TokenStream {
         quote! { #inner_body_with_resources }
     };
 
-    // Build the original function body
-    // The original function preserves the user's signature and return type.
+    // The original function preserves the user's exact signature and body.
     // Resource parameters are passed directly by the caller, NOT injected from context.
-    let original_fn_body = {
-        quote! {
-            let mut dummy_r = ::mingling::RenderResult::default();
-            {
-                let __renderer_inner_result = &mut dummy_r;
-                #(#fn_body_stmts)*
-            }
-            #result_return
-        }
-    };
-
-    // Keep the original function signature unchanged (same params as user wrote)
     let original_inputs = input_fn.sig.inputs.clone();
+    let original_return_type = user_return_type.clone().unwrap_or(quote! { () });
 
     let expanded = quote! {
         #(#fn_attrs)*
@@ -149,15 +112,17 @@ pub fn renderer_attr(attr: TokenStream, item: TokenStream) -> TokenStream {
         impl ::mingling::Renderer for #struct_name {
             type Previous = #previous_type;
 
-            fn render(#prev_param: Self::Previous, __renderer_inner_result: &mut ::mingling::RenderResult) {
-                #render_fn_body
+            fn render(#prev_param: Self::Previous) -> ::mingling::RenderResult {
+                let __renderer_result = { #render_fn_body };
+                ::std::convert::Into::into(__renderer_result)
             }
         }
 
-        // Keep the original function for internal use (without r parameter)
+        // Keep the original function unchanged
+        #[allow(dead_code)]
         #(#fn_attrs)*
-        #vis fn #fn_name(#original_inputs) -> #public_return_type {
-            #original_fn_body
+        #vis fn #fn_name(#original_inputs) -> #original_return_type {
+            #(#fn_body_stmts)*
         }
     };