Derive macro for StructuredParameters

Cargo.toml

@@ -1,5 +1,6 @@
 [workspace]
 members = [
   "rclrs",
+  "rclrs-macros",
 ]
 resolver = "2"

rclrs-macros/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name= "rclrs-macros"
+version = "0.0.1"
+authors = ["Balthasar Schüss <rclrs@bschuess.dev>"]
+edition = "2021"
+license = "Apache-2.0"
+description = "A rust library providing proc macros for rclrs"
+rust-version = "1.85"
+
+
+[lib]
+path = "src/lib.rs"
+proc-macro = true
+
+[dependencies]
+proc-macro2 = "1.0"
+quote = "1.0"
+syn = "2.0"

rclrs-macros/package.xml

@@ -0,0 +1,18 @@
+<?xml version="1.0"?>
+<?xml-model
+   href="http://download.ros.org/schema/package_format3.xsd"
+   schematypens="http://www.w3.org/2001/XMLSchema"?>
+<package format="3">
+  <name>rclrs-macros</name>
+  <version>0.5.0</version>
+  <description>Package containing procedural macros for the Rust client library.</description>
+  <maintainer email="esteve@apache.org">Esteve Fernandez</maintainer>
+  <maintainer email="nnmmgit@gmail.com">Nikolai Morin</maintainer>
+  <!-- This project is not military-sponsored, Jacob's employment contract just requires him to use this email address -->
+  <maintainer email="jacob.a.hassold.civ@army.mil">Jacob Hassold</maintainer>
+  <license>Apache License 2.0</license>
+  <author email="rclrs@bschuess.dev">Balthasar Schüss</author>
+  <export>
+    <build_type>ament_cargo</build_type>
+  </export>
+</package>

rclrs-macros/src/impl.rs

@@ -0,0 +1,162 @@
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::{DeriveInput, Expr};
+
+pub(crate) fn derive_structured_parameters(input: DeriveInput) -> syn::Result<TokenStream> {
+    let ident = input.ident;
+
+    match input.data {
+        syn::Data::Struct(ref s) => derive_structured_parameters_struct(ident, s),
+        _ => {
+            return syn::Result::Err(syn::Error::new_spanned(
+                ident,
+                "StructuredParameters trait can only be derived for structs",
+            ));
+        }
+    }
+}
+
+fn derive_structured_parameters_struct(
+    ident: proc_macro2::Ident,
+    struct_: &syn::DataStruct,
+) -> syn::Result<TokenStream> {
+    let fields = &struct_.fields;
+
+    let field_types: Vec<_> = fields.iter().map(|f| &f.ty).collect();
+    let mut args = Vec::new();
+    for f in fields {
+        let ident = f.ident.as_ref().unwrap();
+        let ident_str = syn::LitStr::new(&f.ident.as_ref().unwrap().to_string(), ident.span());
+
+        let mut default: Option<Expr> = None;
+        let mut description: Option<Expr> = None;
+        let mut constraints: Option<Expr> = None;
+        let mut ignore_override = false;
+        let mut discard_mismatching_prior_value = false;
+        let mut discriminate: Option<Expr> = None;
+        let mut range: Option<Expr> = None;
+
+        for attr in &f.attrs {
+            if attr.path().is_ident("param") {
+                attr.parse_nested_meta(|meta| {
+                    if meta.path.is_ident("default") {
+                        default = Some(meta.value()?.parse()?);
+                        Ok(())
+                    } else if meta.path.is_ident("description") {
+                        description = Some(meta.value()?.parse()?);
+                        Ok(())
+                    } else if meta.path.is_ident("constraints") {
+                        constraints = Some(meta.value()?.parse()?);
+                        Ok(())
+                    } else if meta.path.is_ident("ignore_override") {
+                        ignore_override = true;
+                        Ok(())
+                    } else if meta.path.is_ident("discard_mismatching_prior_value") {
+                        discard_mismatching_prior_value = true;
+                        Ok(())
+                    } else if meta.path.is_ident("discriminate") {
+                        discriminate = Some(meta.value()?.parse()?);
+                        Ok(())
+                    } else if meta.path.is_ident("range") {
+                        range = Some(meta.value()?.parse()?);
+                        Ok(())
+                    } else {
+                        let err = format!("Unknown key: {:?}", &meta.path.get_ident());
+                        syn::Result::Err(syn::Error::new_spanned(meta.path, err))
+                    }
+                })?;
+            }
+        }
+
+        let default = match default {
+            Some(expr) => quote! {Some(#expr)},
+            None => quote! {None},
+        };
+        let description = match description {
+            Some(expr) => quote! {#expr},
+            None => quote! {""},
+        };
+        let constraints = match constraints {
+            Some(expr) => quote! {#expr},
+            None => quote! {""},
+        };
+        let discriminate = match discriminate {
+            Some(expr) => quote! {
+                core::option::Option::Some(Box::new(#expr))
+            },
+            None => quote! {core::option::Option::None},
+        };
+        let range = match range {
+            Some(expr) => quote! {
+                core::option::Option::Some(#expr)
+            },
+            None => quote! {core::option::Option::None},
+        };
+
+        let field_type = match &f.ty {
+            syn::Type::Path(p) => {
+                let mut p = p.path.clone();
+                for segment in &mut p.segments {
+                    segment.arguments = syn::PathArguments::None;
+                }
+                p
+            }
+            e => {
+                return syn::Result::Err(syn::Error::new_spanned(
+                    e,
+                    "Only PathType attributes are supported",
+                ));
+            }
+        };
+        let r = quote! {
+           #ident : #field_type::declare_structured(
+              node,
+              &{match name {
+                    "" => #ident_str.to_string(),
+                    prefix => [prefix, ".", #ident_str].concat(),
+              }},
+              #default,
+              #description,
+              #constraints,
+              #ignore_override,
+              #discard_mismatching_prior_value,
+              #discriminate,
+              #range,
+          )?,
+        };
+        args.push(r);
+    }
+
+    let result = quote!(
+      impl #ident {
+            const _ASSERT_PARAMETER: fn() = || {
+                fn assert_parameter<T: rclrs::parameter::structured::StructuredParameters>() {}
+                #(
+                  assert_parameter::<#field_types>();
+                )*
+            };
+      }
+      impl rclrs::parameter::structured::StructuredParametersMeta<rclrs::parameter::structured::DefaultForbidden> for #ident {
+        fn declare_structured_(
+          node: &rclrs::NodeState,
+          name: &str,
+          default: core::option::Option<rclrs::parameter::structured::DefaultForbidden>,
+          description: impl core::convert::Into<std::sync::Arc<str>>,
+          constraints: impl core::convert::Into<std::sync::Arc<str>>,
+          ignore_override: bool,
+          discard_mismatching_prior_value: bool,
+          discriminate: core::option::Option<Box<
+            dyn core::ops::FnOnce(rclrs::AvailableValues<rclrs::parameter::structured::DefaultForbidden>)
+            -> core::option::Option<rclrs::parameter::structured::DefaultForbidden
+          >>>,
+          range: core::option::Option<<rclrs::structured::DefaultForbidden as rclrs::ParameterVariant>::Range>,
+        )
+          -> core::result::Result<Self, rclrs::DeclarationError> {
+              core::result::Result::Ok(Self{ #(#args)*})
+          }
+
+      }
+      impl rclrs::StructuredParameters for #ident {}
+    );
+    syn::Result::Ok(result)
+}

rclrs-macros/src/lib.rs

@@ -0,0 +1,11 @@
+mod r#impl;
+use proc_macro::TokenStream;
+use syn::{parse_macro_input, DeriveInput};
+
+#[proc_macro_derive(StructuredParameters, attributes(param))]
+pub fn derive_structured_parameters(input: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(input as DeriveInput);
+    r#impl::derive_structured_parameters(input)
+        .unwrap_or_else(|e| e.to_compile_error())
+        .into()
+}

rclrs/Cargo.toml

@@ -59,6 +59,7 @@ uuid = { version = "1", features = ["v4"] }
 tempfile = "3.3.0"
 # Needed for parameter service tests
 tokio = { version = "1", features = ["rt", "time", "macros"] }
+rclrs-macros = {path = "../rclrs-macros"}
 
 [build-dependencies]
 # Needed for uploading documentation to docs.rs

rclrs/package.xml

@@ -19,6 +19,7 @@
   <depend>builtin_interfaces</depend>
   <depend>rcl_interfaces</depend>
   <depend>rosgraph_msgs</depend>
+  <depend>rclrs-macros</depend>
 
   <test_depend>test_msgs</test_depend>
   <test_depend>example_interfaces</test_depend>

rclrs/src/lib.rs

@@ -217,7 +217,10 @@ pub use error::*;
 pub use executor::*;
 pub use logging::*;
 pub use node::*;
-pub use parameter::*;
+pub use parameter::{
+    structured::{StructuredParameters, StructuredParametersMeta},
+    *,
+};
 pub use publisher::*;
 pub use qos::*;
 pub use rcl_bindings::rmw_request_id_t;

rclrs/src/parameter.rs

@@ -1,6 +1,7 @@
 mod override_map;
 mod range;
 mod service;
+pub mod structured;
 mod value;
 
 pub(crate) use override_map::*;