3 files changed, 189 insertions, 0 deletions
diff --git a/mingling_macros/src/extensions/buffer.rs b/mingling_macros/src/extensions/buffer.rs
new file mode 100644
index 0000000..27eb612
--- /dev/null
+++ b/mingling_macros/src/extensions/buffer.rs
@@ -0,0 +1,95 @@
+use proc_macro::TokenStream;
+use quote::quote;
+use syn::spanned::Spanned;
+use syn::{ItemFn, ReturnType, Type, parse_macro_input};
+
+/// Checks whether the return type is unit `()`.
+fn is_unit_return_type(sig: &syn::Signature) -> bool {
+    match &sig.output {
+        ReturnType::Type(_, ty) => match &**ty {
+            Type::Tuple(tuple) => tuple.elems.is_empty(),
+            _ => false,
+        },
+        ReturnType::Default => true,
+    }
+}
+
+/// The `#[buffer]` attribute macro.
+///
+/// Wraps a unit-returning function to produce a `::mingling::RenderResult` by
+/// injecting a local `__render_result_buffer` variable. Inside the function
+/// body, the `r_print!` / `r_println!` macros can write into the buffer.
+///
+/// # Example
+///
+/// ```rust,ignore
+/// use mingling::macros::{buffer, r_println};
+///
+/// #[buffer]
+/// fn render_greeting(prev: Greeting) {
+///     r_println!("Hello, {}!", *prev);
+/// }
+/// ```
+///
+/// Expands to:
+///
+/// ```rust,ignore
+/// fn render_greeting(prev: Greeting) -> mingling::RenderResult {
+///     let mut __render_result_buffer = mingling::RenderResult::new();
+///     {
+///         r_println!("Hello, {}!", *prev);
+///     }
+///     __render_result_buffer
+/// }
+/// ```
+pub(crate) fn buffer_impl(attr: TokenStream, item: TokenStream) -> TokenStream {
+    // Reject non-empty attribute arguments; #[buffer] must be bare
+    if !attr.is_empty() {
+        return syn::Error::new(
+            attr.into_iter().next().unwrap().span().into(),
+            "#[buffer] does not accept arguments",
+        )
+        .to_compile_error()
+        .into();
+    }
+
+    // Parse the function item
+    let input_fn = parse_macro_input!(item as ItemFn);
+
+    // Validate the function is not async
+    if input_fn.sig.asyncness.is_some() {
+        return syn::Error::new(input_fn.sig.span(), "Buffer function cannot be async")
+            .to_compile_error()
+            .into();
+    }
+
+    // Validate return type is unit
+    if !is_unit_return_type(&input_fn.sig) {
+        return syn::Error::new(
+            input_fn.sig.span(),
+            "#[buffer] function must not have a return value (must return `()`)",
+        )
+        .to_compile_error()
+        .into();
+    }
+
+    // Get function attributes (excluding the buffer attribute)
+    let mut fn_attrs = input_fn.attrs.clone();
+    fn_attrs.retain(|attr| !attr.path().is_ident("buffer"));
+
+    let vis = &input_fn.vis;
+    let fn_name = &input_fn.sig.ident;
+    let inputs = &input_fn.sig.inputs;
+    let fn_body = &input_fn.block;
+
+    let expanded = quote! {
+        #(#fn_attrs)*
+        #vis fn #fn_name(#inputs) -> ::mingling::RenderResult {
+            let mut __render_result_buffer = ::mingling::RenderResult::new();
+            #fn_body
+            __render_result_buffer
+        }
+    };
+
+    expanded.into()
+}
diff --git a/mingling_macros/src/extensions/renderify.rs b/mingling_macros/src/extensions/renderify.rs
new file mode 100644
index 0000000..9be8acc
--- /dev/null
+++ b/mingling_macros/src/extensions/renderify.rs
@@ -0,0 +1,48 @@
+//! The `#[renderify]` extension — transforms `expr?` into `render_route!(expr)`.
+//!
+//! Designed as an extension for the Mingling attribute macro system, intended
+//! to be used with `#[renderer(renderify)]`, `#[help(renderify)]`,
+//! or standalone as `#[renderify]`.
+//!
+//! # How it works
+//!
+//! The macro parses the function AST and replaces every `Expr::Try` node with an
+//! equivalent `render_route!(expr)` invocation, which routes errors to the
+//! rendering pipeline via `crate::ThisProgram::render(AnyOutput::new(e))`.
+
+use proc_macro::TokenStream;
+use quote::ToTokens;
+use syn::spanned::Spanned;
+use syn::visit_mut::VisitMut;
+use syn::{Expr, ItemFn, parse_macro_input};
+
+struct RenderifyTransform;
+
+impl VisitMut for RenderifyTransform {
+    fn visit_expr_mut(&mut self, expr: &mut Expr) {
+        syn::visit_mut::visit_expr_mut(self, expr);
+
+        if let Expr::Try(try_expr) = expr {
+            let inner = &*try_expr.expr;
+            let inner_tokens = inner.to_token_stream();
+
+            // Set the span of the generated `render_route` ident to the `?` token's span,
+            // so that rust-analyzer resolves the `?` position to the `render_route!` macro
+            // instead of the standard Try trait, showing the render_route macro's docs on hover.
+            let q_span = try_expr.question_token.span();
+            let route_ident = proc_macro2::Ident::new("render_route", q_span);
+
+            if let Ok(macro_expr) = syn::parse2::<Expr>(quote::quote! {
+                ::mingling::macros::#route_ident!(#inner_tokens)
+            }) {
+                *expr = macro_expr;
+            }
+        }
+    }
+}
+
+pub(crate) fn renderify_impl(_attr: TokenStream, item: TokenStream) -> TokenStream {
+    let mut input_fn = parse_macro_input!(item as ItemFn);
+    RenderifyTransform.visit_item_fn_mut(&mut input_fn);
+    input_fn.to_token_stream().into()
+}
diff --git a/mingling_macros/src/extensions/routeify.rs b/mingling_macros/src/extensions/routeify.rs
new file mode 100644
index 0000000..7cded54
--- /dev/null
+++ b/mingling_macros/src/extensions/routeify.rs
@@ -0,0 +1,46 @@
+//! The `#[routeify]` extension — transforms `expr?` into `route!(expr)`.
+//!
+//! Designed as an extension for the Mingling attribute macro system, intended
+//! to be used with `#[chain(routeify)]` or standalone as `#[routeify]`.
+//!
+//! # How it works
+//!
+//! The macro parses the function AST and replaces every `Expr::Try` node with an
+//! equivalent `route!(expr)` invocation.
+
+use proc_macro::TokenStream;
+use quote::ToTokens;
+use syn::spanned::Spanned;
+use syn::visit_mut::VisitMut;
+use syn::{Expr, ItemFn, parse_macro_input};
+
+struct RouteifyTransform;
+
+impl VisitMut for RouteifyTransform {
+    fn visit_expr_mut(&mut self, expr: &mut Expr) {
+        syn::visit_mut::visit_expr_mut(self, expr);
+
+        if let Expr::Try(try_expr) = expr {
+            let inner = &*try_expr.expr;
+            let inner_tokens = inner.to_token_stream();
+
+            // Set the span of the generated `route` ident to the `?` token's span,
+            // so that rust-analyzer resolves the `?` position to the `route!` macro
+            // instead of the standard Try trait, showing the route macro's docs on hover.
+            let q_span = try_expr.question_token.span();
+            let route_ident = proc_macro2::Ident::new("route", q_span);
+
+            if let Ok(macro_expr) = syn::parse2::<Expr>(quote::quote! {
+                ::mingling::macros::#route_ident!(#inner_tokens)
+            }) {
+                *expr = macro_expr;
+            }
+        }
+    }
+}
+
+pub(crate) fn routeify_impl(_attr: TokenStream, item: TokenStream) -> TokenStream {
+    let mut input_fn = parse_macro_input!(item as ItemFn);
+    RouteifyTransform.visit_item_fn_mut(&mut input_fn);
+    input_fn.to_token_stream().into()
+}