serde_derive: Add alias_all attribute to containers

This adds a new attribute `#[serde(alias_all = "...")]` to containers,
which accepts the same rename rules as `#[serde(rename_all = "...")]`.
When applied to a container, the alias will be added to all fields (or variants)
similarly to how `#[serde(alias = "...")]` works on a single field/variant.

This attribute can be specified multiple times, with the use-case being
accepting multiple case styles during de-serialization.

Resolves #1530

Signed-off-by: Michel Heily <[email protected]>

Author: michelhe

serde_derive/src/internals/ast.rs

@@ -80,8 +80,14 @@ impl<'a> Container<'a> {
         match &mut data {
             Data::Enum(variants) => {
                 for variant in variants {
+                    for alias_all_rule in attrs.alias_all_rules() {
+                        variant.attrs.alias_by_rule(*alias_all_rule);
+                    }
                     variant.attrs.rename_by_rules(attrs.rename_all_rules());
                     for field in &mut variant.fields {
+                        for alias_all_rule in attrs.alias_all_rules() {
+                            field.attrs.alias_by_rule(*alias_all_rule);
+                        }
                         field.attrs.rename_by_rules(
                             variant
                                 .attrs
@@ -93,6 +99,9 @@ impl<'a> Container<'a> {
             }
             Data::Struct(_, fields) => {
                 for field in fields {
+                    for alias_all_rule in attrs.alias_all_rules() {
+                        field.attrs.alias_by_rule(*alias_all_rule);
+                    }
                     field.attrs.rename_by_rules(attrs.rename_all_rules());
                 }
             }

serde_derive/src/internals/attr.rs

@@ -160,6 +160,7 @@ pub struct Container {
     default: Default,
     rename_all_rules: RenameAllRules,
     rename_all_fields_rules: RenameAllRules,
+    alias_all_rules: Vec<RenameRule>,
     ser_bound: Option<Vec<syn::WherePredicate>>,
     de_bound: Option<Vec<syn::WherePredicate>>,
     tag: TagType,
@@ -245,6 +246,7 @@ impl Container {
         let mut rename_all_de_rule = Attr::none(cx, RENAME_ALL);
         let mut rename_all_fields_ser_rule = Attr::none(cx, RENAME_ALL_FIELDS);
         let mut rename_all_fields_de_rule = Attr::none(cx, RENAME_ALL_FIELDS);
+        let mut alias_all_rules = VecAttr::none(cx, ALIAS_ALL);
         let mut ser_bound = Attr::none(cx, BOUND);
         let mut de_bound = Attr::none(cx, BOUND);
         let mut untagged = BoolAttr::none(cx, UNTAGGED);
@@ -491,6 +493,14 @@ impl Container {
                     if let Some(s) = get_lit_str(cx, EXPECTING, &meta)? {
                         expecting.set(&meta.path, s.value());
                     }
+                } else if meta.path == ALIAS_ALL {
+                    // #[serde(alias_all = "...")]
+                    if let Some(s) = get_lit_str(cx, ALIAS_ALL, &meta)? {
+                        match RenameRule::from_str(&s.value()) {
+                            Ok(rename_rule) => alias_all_rules.insert(&meta.path, rename_rule),
+                            Err(err) => cx.error_spanned_by(s, err),
+                        }
+                    }
                 } else {
                     let path = meta.path.to_token_stream().to_string().replace(' ', "");
                     return Err(
@@ -530,6 +540,7 @@ impl Container {
                 serialize: rename_all_fields_ser_rule.get().unwrap_or(RenameRule::None),
                 deserialize: rename_all_fields_de_rule.get().unwrap_or(RenameRule::None),
             },
+            alias_all_rules: alias_all_rules.get(),
             ser_bound: ser_bound.get(),
             de_bound: de_bound.get(),
             tag: decide_tag(cx, item, untagged, internal_tag, content),
@@ -569,6 +580,10 @@ impl Container {
         &self.default
     }
 
+    pub fn alias_all_rules(&self) -> &[RenameRule] {
+        &self.alias_all_rules
+    }
+
     pub fn ser_bound(&self) -> Option<&[syn::WherePredicate]> {
         self.ser_bound.as_ref().map(|vec| &vec[..])
     }
@@ -943,6 +958,15 @@ impl Variant {
             .insert(self.name.deserialize.clone());
     }
 
+    pub fn alias_by_rule(&mut self, rule: RenameRule) {
+        let alias_name = rule.apply_to_variant(&self.name.deserialize.value);
+        let alias = Name {
+            value: alias_name,
+            span: self.name.deserialize.span,
+        };
+        self.name.deserialize_aliases.insert(alias);
+    }
+
     pub fn rename_all_rules(&self) -> RenameAllRules {
         self.rename_all_rules
     }
@@ -1341,6 +1365,16 @@ impl Field {
     pub fn mark_transparent(&mut self) {
         self.transparent = true;
     }
+
+    pub fn alias_by_rule(&mut self, rule: RenameRule) {
+        // Apply the rename rule to the original field name to create an alias
+        let alias_name = rule.apply_to_field(&self.name.deserialize.value);
+        let alias = Name {
+            value: alias_name,
+            span: self.name.deserialize.span,
+        };
+        self.name.deserialize_aliases.insert(alias);
+    }
 }
 
 type SerAndDe<T> = (Option<T>, Option<T>);

serde_derive/src/internals/symbol.rs

@@ -5,6 +5,7 @@ use syn::{Ident, Path};
 pub struct Symbol(&'static str);
 
 pub const ALIAS: Symbol = Symbol("alias");
+pub const ALIAS_ALL: Symbol = Symbol("alias_all");
 pub const BORROW: Symbol = Symbol("borrow");
 pub const BOUND: Symbol = Symbol("bound");
 pub const CONTENT: Symbol = Symbol("content");