rust: targeted attribute injection via additional_type_attributes/additional_member_attributes

Author: wilfreddenton

crates/guest-rust/macro/src/lib.rs

@@ -127,6 +127,10 @@ impl Parse for Config {
                         opts.additional_derive_ignore =
                             list.into_iter().map(|i| i.value()).collect()
                     }
+                    Opt::AdditionalTypeAttributes(list) => opts.additional_type_attributes = list,
+                    Opt::AdditionalMemberAttributes(list) => {
+                        opts.additional_member_attributes = list
+                    }
                     Opt::With(with) => opts.with.extend(with),
                     Opt::GenerateAll => {
                         opts.generate_all = true;
@@ -237,7 +241,7 @@ fn parse_source(
                     }
                 }
             }
-            pkgs.truncate(0);
+            pkgs.clear();
             pkgs.push(resolve.push_str("macro-input", s)?);
         }
         Some(Source::Paths(p)) => parse(p)?,
@@ -312,6 +316,8 @@ mod kw {
     syn::custom_keyword!(export_prefix);
     syn::custom_keyword!(additional_derives);
     syn::custom_keyword!(additional_derives_ignore);
+    syn::custom_keyword!(additional_type_attributes);
+    syn::custom_keyword!(additional_member_attributes);
     syn::custom_keyword!(with);
     syn::custom_keyword!(generate_all);
     syn::custom_keyword!(type_section_suffix);
@@ -394,6 +400,8 @@ enum Opt {
     // Parse as paths so we can take the concrete types/macro names rather than raw strings
     AdditionalDerives(Vec<syn::Path>),
     AdditionalDerivesIgnore(Vec<syn::LitStr>),
+    AdditionalTypeAttributes(Vec<(String, String)>),
+    AdditionalMemberAttributes(Vec<(String, String)>),
     With(HashMap<String, WithOption>),
     GenerateAll,
     TypeSectionSuffix(syn::LitStr),
@@ -522,6 +530,26 @@ impl Parse for Opt {
             syn::bracketed!(contents in input);
             let list = Punctuated::<_, Token![,]>::parse_terminated(&contents)?;
             Ok(Opt::AdditionalDerivesIgnore(list.iter().cloned().collect()))
+        } else if l.peek(kw::additional_type_attributes) {
+            input.parse::<kw::additional_type_attributes>()?;
+            input.parse::<Token![:]>()?;
+            let contents;
+            braced!(contents in input);
+            let fields: Punctuated<_, Token![,]> =
+                contents.parse_terminated(attr_map_field_parse, Token![,])?;
+            Ok(Opt::AdditionalTypeAttributes(
+                fields.into_iter().flatten().collect(),
+            ))
+        } else if l.peek(kw::additional_member_attributes) {
+            input.parse::<kw::additional_member_attributes>()?;
+            input.parse::<Token![:]>()?;
+            let contents;
+            braced!(contents in input);
+            let fields: Punctuated<_, Token![,]> =
+                contents.parse_terminated(attr_map_field_parse, Token![,])?;
+            Ok(Opt::AdditionalMemberAttributes(
+                fields.into_iter().flatten().collect(),
+            ))
         } else if l.peek(kw::with) {
             input.parse::<kw::with>()?;
             input.parse::<Token![:]>()?;
@@ -601,6 +629,29 @@ impl Parse for Opt {
     }
 }
 
+// Parse one `"selector": ["#[attr]", ...]` entry into a (selector, attribute) pair
+// per attribute.
+fn attr_map_field_parse(input: ParseStream<'_>) -> Result<Vec<(String, String)>> {
+    let selector = input.parse::<syn::LitStr>()?;
+    input.parse::<Token![:]>()?;
+    let contents;
+    let bracket = syn::bracketed!(contents in input);
+    let attrs = Punctuated::<syn::LitStr, Token![,]>::parse_terminated(&contents)?;
+    // An empty list would otherwise flatten away silently and escape the
+    // unused-selector check in the generator.
+    if attrs.is_empty() {
+        return Err(Error::new(
+            bracket.span.join(),
+            "attribute list must not be empty",
+        ));
+    }
+    let selector = selector.value();
+    Ok(attrs
+        .into_iter()
+        .map(|a| (selector.clone(), a.value()))
+        .collect())
+}
+
 fn with_field_parse(input: ParseStream<'_>) -> Result<(String, WithOption)> {
     let interface = input.parse::<syn::LitStr>()?.value();
     input.parse::<Token![:]>()?;

crates/guest-rust/src/lib.rs

@@ -682,6 +682,31 @@ extern crate std;
 ///     // By default this set is empty.
 ///     additional_derives: [PartialEq, Eq, Hash, Clone],
 ///
+///     // Extra attributes to emit on specific generated types (records, variants,
+///     // and enums), rather than on all types like `additional_derives`. A type is
+///     // selected by its bare kebab name, its package (`my:pkg`), its owning
+///     // interface (`my:pkg/types`), or its fully-qualified name; the qualified
+///     // forms written as in `with`, carrying the `@version` when versioned. An
+///     // injected `#[derive(...)]` folds into the generated derive (deduped); other
+///     // attributes are emitted verbatim, on every form including the borrowed one
+///     // under `Borrowing` (so owned-only derives fail there). See the CLI docs for
+///     // the full grammar.
+///     //
+///     // By default this map is empty.
+///     additional_type_attributes: {
+///         "my-record": [r#"#[derive(serde::Serialize)]"#],   // one type, by bare name
+///         "my:pkg/types": [r#"#[derive(Clone)]"#],           // every type in an interface
+///     },
+///
+///     // Like `additional_type_attributes`, but for generated record fields and
+///     // enum/variant cases, selected by `<type-selector>.member-name` (any type
+///     // selector above) or a bare `member-name`.
+///     //
+///     // By default this map is empty.
+///     additional_member_attributes: {
+///         "my-record.my-field": [r#"#[serde(rename = "mf")]"#],
+///     },
+///
 ///     // When generating bindings for interfaces that are not defined in the
 ///     // same package as `world`, this option can be used to either generate
 ///     // those bindings or point to already generated bindings.