Merge pull request #27 from zeenix/field-visibility-spec

Allow visibility specifiers on struct fields

Author: zeenix

CHANGELOG.md

@@ -1,3 +1,7 @@
+# 0.4.1 (Nov 26th, 2025)
+
+* Allow specifying visibility on struct fields.
+
 # 0.4.0 (Nov 26th, 2025)
 
 ## Breaking Changes

Cargo.lock

@@ -1,7 +1,7 @@
 [package]
 name = "firmware-controller"
 description = "Controller to decouple interactions between components in a no_std environment."
-version = "0.4.0"
+version = "0.4.1"
 edition = "2021"
 authors = [
     "Zeeshan Ali Khan <[email protected]>",

Cargo.toml

@@ -129,6 +129,12 @@ pub(crate) fn expand(mut input: ItemStruct) -> Result<ExpandedStruct> {
         .collect();
 
     let fields = struct_fields.raw_fields().collect::<Vec<_>>();
+    // Generate function parameters without visibility (visibility is only valid on struct fields).
+    let new_fn_params = fields.iter().map(|f| {
+        let ident = f.ident.as_ref().unwrap();
+        let ty = &f.ty;
+        quote! { #ident: #ty }
+    });
     let vis = &input.vis;
 
     // Generate initial value sends for Watch channels.
@@ -149,7 +155,7 @@ pub(crate) fn expand(mut input: ItemStruct) -> Result<ExpandedStruct> {
 
             impl #struct_name {
                 #[allow(clippy::too_many_arguments)]
-                pub fn new(#(#fields),*) -> Self {
+                pub fn new(#(#new_fn_params),*) -> Self {
                     let __self = Self {
                         #(#field_names),*,
                         #sender_fields_initializations

src/controller/item_struct.rs

@@ -219,3 +219,57 @@ fn test_controller_basic_functionality() {
 async fn controller_task(controller: Controller) {
     controller.run().await;
 }
+
+/// Test that visibility specifiers on struct fields are preserved.
+#[controller]
+mod visibility_test_controller {
+    pub struct Controller {
+        #[controller(getter)]
+        pub public_field: u32,
+        #[controller(getter)]
+        pub(crate) crate_field: i32,
+        #[controller(getter)]
+        private_field: bool,
+    }
+
+    impl Controller {}
+}
+
+#[test]
+fn test_visibility_on_fields() {
+    // Verify struct compiles and fields have correct visibility.
+    let controller = visibility_test_controller::Controller::new(42, -1, true);
+
+    // Public field should be accessible.
+    assert_eq!(controller.public_field, 42);
+
+    // pub(crate) field should be accessible within this crate.
+    assert_eq!(controller.crate_field, -1);
+
+    // Note: private_field is not accessible here, which is correct.
+    // We can only access it through the method.
+
+    // Run the controller in a background thread.
+    std::thread::spawn(move || {
+        let executor = Box::leak(Box::new(embassy_executor::Executor::new()));
+        executor.run(move |spawner| {
+            spawner
+                .spawn(visibility_controller_task(controller))
+                .unwrap();
+        });
+    });
+
+    futures::executor::block_on(async {
+        let client = visibility_test_controller::ControllerClient::new();
+
+        // Use generated getters from #[controller(getter)] attribute.
+        assert_eq!(client.public_field().await, 42);
+        assert_eq!(client.crate_field().await, -1);
+        assert_eq!(client.private_field().await, true);
+    });
+}
+
+#[embassy_executor::task]
+async fn visibility_controller_task(controller: visibility_test_controller::Controller) {
+    controller.run().await;
+}