1 files changed, 137 insertions, 13 deletions
diff --git a/mingling_macros/src/completion.rs b/mingling_macros/src/completion.rs
index 720ac49..452c418 100644
--- a/mingling_macros/src/completion.rs
+++ b/mingling_macros/src/completion.rs
@@ -1,11 +1,12 @@
+use crate::res_injection::{ResourceInjection, generate_immut_resource_bindings};
 use proc_macro::TokenStream;
 use quote::quote;
-use syn::{Ident, ItemFn, TypePath, parse_macro_input};
+use syn::spanned::Spanned;
+use syn::{FnArg, Ident, ItemFn, Pat, PatType, Type, TypePath, parse_macro_input};
 
 #[cfg(feature = "comp")]
 pub fn completion_attr(attr: TokenStream, item: TokenStream) -> TokenStream {
-    // Parse the attribute arguments (e.g., HelloEntry or crate::EntryFine from #[completion(crate::EntryFine)])
-
+    // Parse the attribute arguments such as HelloEntry or crate::EntryFine from #[completion(crate::EntryFine)]
     use crate::get_global_set;
     let previous_type_path: TypePath = if attr.is_empty() {
         return syn::Error::new(
@@ -24,8 +25,6 @@ pub fn completion_attr(attr: TokenStream, item: TokenStream) -> TokenStream {
 
     // Validate the function is not async
     if input_fn.sig.asyncness.is_some() {
-        use syn::spanned::Spanned;
-
         return syn::Error::new(input_fn.sig.span(), "Completion function cannot be async")
             .to_compile_error()
             .into();
@@ -36,22 +35,44 @@ pub fn completion_attr(attr: TokenStream, item: TokenStream) -> TokenStream {
     let inputs = &sig.inputs;
     let output = &sig.output;
 
-    // Check that the function has exactly one parameter
-    if inputs.len() != 1 {
-        use syn::spanned::Spanned;
-
+    // Must have at least one parameter ctx
+    if inputs.is_empty() {
         return syn::Error::new(
             inputs.span(),
-            "Completion function must have exactly one parameter",
+            "Completion function must have at least one parameter: `ctx: &ShellContext`",
         )
         .to_compile_error()
         .into();
     }
 
+    // Extract the first param pattern and type for the ctx parameter
+    let first_arg = &inputs[0];
+    let (ctx_pat, _ctx_type) = match first_arg {
+        FnArg::Typed(PatType { pat, ty, .. }) => {
+            let param_pat = (**pat).clone();
+            (param_pat, (**ty).clone())
+        }
+        FnArg::Receiver(_) => {
+            return syn::Error::new(
+                first_arg.span(),
+                "Completion function cannot have self parameter",
+            )
+            .to_compile_error()
+            .into();
+        }
+    };
+
+    // Extract resources from params 2 through N, skipping ctx
+    let resources = match extract_resources_from_args(sig, 1) {
+        Ok(r) => r,
+        Err(e) => return e.to_compile_error().into(),
+    };
+
     // Get the function body
     let fn_body = &input_fn.block;
+    let fn_body_stmts = &fn_body.stmts;
 
-    // Get function attributes (excluding the completion attribute)
+    // Get function attributes excluding the completion attribute
     let mut fn_attrs = input_fn.attrs.clone();
     fn_attrs.retain(|attr| !attr.path().is_ident("completion"));
 
@@ -68,7 +89,43 @@ pub fn completion_attr(attr: TokenStream, item: TokenStream) -> TokenStream {
     );
     let struct_name = Ident::new(&internal_name, fn_name.span());
 
+    let program_type = crate::default_program_path();
+    let has_resources = !resources.is_empty();
+    let mut_resources: Vec<_> = resources.iter().filter(|r| r.is_mut).collect();
+
+    // Generate immutable resource bindings
+    let immut_resource_stmts = generate_immut_resource_bindings(resources.iter(), &program_type);
+
+    // Build the comp method body with resource injection
+    // Use modify_res for mutable resources same pattern as renderer.rs
+    let wrapped_body = if mut_resources.is_empty() {
+        quote! { #(#fn_body_stmts)* }
+    } else {
+        let mut wrapped = quote! { #(#fn_body_stmts)* };
+        for res in mut_resources.iter().rev() {
+            let var_name = &res.var_name;
+            let inner_type = &res.inner_type;
+            wrapped = quote! {
+                ::mingling::this::<#program_type>().modify_res(|#var_name: &mut #inner_type| {
+                    #wrapped
+                })
+            };
+        }
+        wrapped
+    };
+
+    let comp_body = if has_resources {
+        quote! {
+            #(#immut_resource_stmts)*
+            #wrapped_body
+        }
+    } else {
+        quote! { #(#fn_body_stmts)* }
+    };
+
     // Generate the struct and implementation
+    // The `comp` trait method only takes `ctx` as the first parameter; resources are injected internally
+
     let expanded = quote! {
         #(#fn_attrs)*
         #[doc(hidden)]
@@ -78,8 +135,8 @@ pub fn completion_attr(attr: TokenStream, item: TokenStream) -> TokenStream {
         impl ::mingling::Completion for #struct_name {
             type Previous = #previous_type_path;
 
-            fn comp(#inputs) #output {
-                #fn_body
+            fn comp(#ctx_pat: &::mingling::ShellContext) #output {
+                #comp_body
             }
         }
 
@@ -100,3 +157,70 @@ pub fn completion_attr(attr: TokenStream, item: TokenStream) -> TokenStream {
 
     expanded.into()
 }
+
+/// Extract resource injection parameters from function arguments (skipping the first N params).
+fn extract_resources_from_args(
+    sig: &syn::Signature,
+    skip: usize,
+) -> syn::Result<Vec<ResourceInjection>> {
+    let mut resources = Vec::new();
+    for arg in sig.inputs.iter().skip(skip) {
+        match arg {
+            FnArg::Typed(PatType { pat, ty, .. }) => {
+                let var_name = match &**pat {
+                    Pat::Ident(pat_ident) => pat_ident.ident.clone(),
+                    _ => {
+                        return Err(syn::Error::new(
+                            pat.span(),
+                            "Resource injection parameter must be a simple identifier",
+                        ));
+                    }
+                };
+
+                let full_type = *(*ty).clone();
+
+                let (inner_type, is_ref, is_mut) = match &full_type {
+                    Type::Reference(ref_type) => match &*ref_type.elem {
+                        Type::Path(type_path) => {
+                            let is_mut = ref_type.mutability.is_some();
+                            (type_path.clone(), true, is_mut)
+                        }
+                        _ => {
+                            return Err(syn::Error::new(
+                                ty.span(),
+                                "Reference resource type must be a type path",
+                            ));
+                        }
+                    },
+                    Type::Path(_) => {
+                        return Err(syn::Error::new(
+                            ty.span(),
+                            "Resource injection parameter must be a reference (`&T` or `&mut T`)",
+                        ));
+                    }
+                    _ => {
+                        return Err(syn::Error::new(
+                            ty.span(),
+                            "Resource injection type must be a type path or reference",
+                        ));
+                    }
+                };
+
+                resources.push(ResourceInjection {
+                    var_name,
+                    full_type,
+                    inner_type,
+                    is_ref,
+                    is_mut,
+                });
+            }
+            FnArg::Receiver(_) => {
+                return Err(syn::Error::new(
+                    arg.span(),
+                    "Resource injection parameter cannot be self",
+                ));
+            }
+        }
+    }
+    Ok(resources)
+}