Derive macro for StructuredParameters

Cargo.toml

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

Dockerfile

@@ -22,8 +22,10 @@ COPY src/ros2_rust/docker/rosidl_rust_setup.sh /
 RUN ./rosidl_rust_setup.sh
 
 RUN mkdir -p /workspace && echo "Did you forget to mount the repository into the Docker container?" > /workspace/HELLO.txt
+RUN echo "\nsource /opt/ros/${ROS_DISTRO}/setup.sh" >> /root/.bashrc
 WORKDIR /workspace
 
+
 COPY src/ros2_rust/docker/rosidl_rust_entrypoint.sh /
 ENTRYPOINT ["/rosidl_rust_entrypoint.sh"]
 CMD ["/bin/bash"]

rclrs-macros/Cargo.toml

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

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

@@ -36,11 +36,13 @@ rosidl_runtime_rs = "0.4"
 serde = { version = "1", optional = true, features = ["derive"] }
 serde-big-array = { version = "0.5.1", optional = true }
 
+
 [dev-dependencies]
 # Needed for e.g. writing yaml files in tests
 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/src/lib.rs

@@ -213,7 +213,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::*;