refactor!: borsh_init to borsh(init).

README.md

@@ -42,13 +42,13 @@ fn test_simple_struct() {
 ## Features
 
 Opting out from Serde allows borsh to have some features that currently are not available for serde-compatible serializers.
-Currently we support two features: `borsh_init` and `borsh_skip` (the former one not available in Serde).
+Currently we support two features: `borsh(init=<your initilization method name>` and `borsh_skip` (the former one not available in Serde).
 
-`borsh_init` allows to automatically run an initialization function right after deserialization. This adds a lot of convenience for objects that are architectured to be used as strictly immutable. Usage example:
+`borsh(init=...)` allows to automatically run an initialization function right after deserialization. This adds a lot of convenience for objects that are architectured to be used as strictly immutable. Usage example:
 
 ```rust
 #[derive(BorshSerialize, BorshDeserialize)]
-#[borsh_init(init)]
+#[borsh(init=init)]
 struct Message {
     message: String,
     timestamp: u64,

borsh-derive/src/internals/attributes/item/mod.rs

@@ -4,20 +4,28 @@ use quote::ToTokens;
 use syn::{spanned::Spanned, Attribute, DeriveInput, Expr, ItemEnum, Path};
 
 pub fn check_item_attributes(derive_input: &DeriveInput) -> Result<(), TokenStream> {
-    for attr in &derive_input.attrs {
-        if attr.path().is_ident(SKIP.0) {
-            return Err(syn::Error::new(
-                derive_input.ident.span(),
-                "`borsh_skip` is not allowed as derive input attribute",
-            )
-            .to_compile_error());
-        }
+    // TODO remove in next P
+    let attr = derive_input
+        .attrs
+        .iter()
+        .find(|attr| attr.path().is_ident(SKIP.0));
+
+    if attr.is_some() {
+        return Err(syn::Error::new(
+            derive_input.ident.span(),
+            "`borsh_skip` is not allowed as derive input attribute",
+        )
+        .to_compile_error());
+    }
+
+    let attr = derive_input.attrs.iter().find(|attr| attr.path() == BORSH);
+    if let Some(attr) = attr {
         if attr.path().is_ident(BORSH.0) {
             attr.parse_nested_meta(|meta| {
-                if !meta.path.is_ident(USE_DISCRIMINANT) {
+                if !meta.path.is_ident(USE_DISCRIMINANT) && meta.path != INIT {
                     return Err(syn::Error::new(
                         meta.path.span(),
-                        "`use_discriminant` is the only supported attribute for `borsh`",
+                        "`use_discriminant` or `init` are only supported attributes for `borsh`",
                     ));
                 }
                 if meta.path.is_ident(USE_DISCRIMINANT) {
@@ -29,6 +37,9 @@ pub fn check_item_attributes(derive_input: &DeriveInput) -> Result<(), TokenStre
                         ));
                     }
                 }
+                if meta.path.is_ident(INIT.0) {
+                    let _expr: Expr = meta.value()?.parse()?;
+                }
 
                 Ok(())
             })
@@ -48,29 +59,31 @@ pub fn contains_use_discriminant(input: &ItemEnum) -> Result<bool, syn::Error> {
 
     let attrs = &input.attrs;
     let mut use_discriminant = None;
-    for attr in attrs {
-        if attr.path().is_ident(BORSH.0) {
-            attr.parse_nested_meta(|meta| {
-                if meta.path.is_ident(USE_DISCRIMINANT) {
-                    let value_expr: Expr = meta.value()?.parse()?;
-                    let value = value_expr.to_token_stream().to_string();
-                    match value.as_str() {
-                        "true" => {
-                            use_discriminant = Some(true);
-                        }
-                        "false" => use_discriminant = Some(false),
-                        _ => {
-                            return Err(syn::Error::new(
-                                value_expr.span(),
-                                "`use_discriminant` accepts only `true` or `false`",
-                            ));
-                        }
-                    };
-                }
+    let attr = attrs.iter().find(|attr| attr.path() == BORSH);
+    if let Some(attr) = attr {
+        attr.parse_nested_meta(|meta| {
+            if meta.path.is_ident(USE_DISCRIMINANT) {
+                let value_expr: Expr = meta.value()?.parse()?;
+                let value = value_expr.to_token_stream().to_string();
+                match value.as_str() {
+                    "true" => {
+                        use_discriminant = Some(true);
+                    }
+                    "false" => use_discriminant = Some(false),
+                    _ => {
+                        return Err(syn::Error::new(
+                            value_expr.span(),
+                            "`use_discriminant` accepts only `true` or `false`",
+                        ));
+                    }
+                };
+            }
 
-                Ok(())
-            })?;
-        }
+            if meta.path == INIT {
+                let _value_expr: Expr = meta.value()?.parse()?;
+            }
+            Ok(())
+        })?;
     }
     let has_explicit_discriminants = input
         .variants
@@ -86,18 +99,21 @@ pub fn contains_use_discriminant(input: &ItemEnum) -> Result<bool, syn::Error> {
 }
 
 pub(crate) fn contains_initialize_with(attrs: &[Attribute]) -> Option<Path> {
-    for attr in attrs.iter() {
-        if attr.path() == INIT {
-            let mut res = None;
-            let _ = attr.parse_nested_meta(|meta| {
-                res = Some(meta.path);
-                Ok(())
-            });
-            return res;
-        }
+    let mut res = None;
+    let attr = attrs.iter().find(|attr| attr.path() == BORSH);
+    if let Some(attr) = attr {
+        let _ = attr.parse_nested_meta(|meta| {
+            if meta.path == INIT {
+                let value_expr: Path = meta.value()?.parse()?;
+                res = Some(value_expr);
+            } else if meta.path.is_ident(USE_DISCRIMINANT) {
+                let _value_expr: Expr = meta.value()?.parse()?;
+            };
+            Ok(())
+        });
     }
 
-    None
+    res
 }
 
 #[cfg(test)]
@@ -199,4 +215,92 @@ mod tests {
         let actual = check_item_attributes(&item_enum);
         local_insta_assert_snapshot!(actual.unwrap_err().to_token_stream().to_string());
     }
+    #[test]
+    fn test_init_function() {
+        let item_struct = syn::parse2::<DeriveInput>(quote! {
+        #[derive(BorshSerialize, BorshDeserialize, PartialEq, Debug)]
+        #[borsh(init = initialization_method)]
+        struct A<'a> {
+            x: u64,
+        }
+                })
+        .unwrap();
+
+        let actual = check_item_attributes(&item_struct);
+        assert!(actual.is_ok());
+    }
+
+    #[test]
+    fn test_init_function_wrong_format() {
+        let item_struct: DeriveInput = syn::parse2(quote! {
+        #[derive(BorshDeserialize, Debug)]
+        #[borsh(init_func = initialization_method)]
+        struct A<'a> {
+            x: u64,
+            b: B,
+            y: f32,
+            z: String,
+            v: Vec<String>,
+
+        }
+            })
+        .unwrap();
+        let actual = check_item_attributes(&item_struct);
+        local_insta_assert_snapshot!(actual.unwrap_err().to_token_stream().to_string());
+    }
+    #[test]
+    fn test_contains_initialize_with_function() {
+        let item_struct = syn::parse2::<DeriveInput>(quote! {
+        #[derive(BorshSerialize, BorshDeserialize, PartialEq, Debug)]
+        #[borsh(init = initialization_method)]
+        struct A<'a> {
+            x: u64,
+        }
+                })
+        .unwrap();
+
+        let actual = contains_initialize_with(&item_struct.attrs);
+        assert_eq!(
+            actual.unwrap().to_token_stream().to_string(),
+            "initialization_method"
+        );
+    }
+
+    #[test]
+    fn test_contains_initialize_with_function_wrong_format() {
+        let item_struct: DeriveInput = syn::parse2(quote! {
+        #[derive(BorshDeserialize, Debug)]
+        #[borsh(init_func = initialization_method)]
+        struct A<'a> {
+            x: u64,
+            b: B,
+            y: f32,
+            z: String,
+            v: Vec<String>,
+
+        }
+            })
+        .unwrap();
+        let actual = contains_initialize_with(&item_struct.attrs);
+        assert!(actual.is_none());
+    }
+
+    #[test]
+    fn test_contains_initialize_with_function_wrong_attr_format() {
+        let item_struct: DeriveInput = syn::parse2(quote! {
+        #[derive(BorshDeserialize, Debug)]
+        #[borsh_init(initialization_method)]
+        struct A<'a> {
+            x: u64,
+            b: B,
+            y: f32,
+            z: String,
+            v: Vec<String>,
+
+        }
+            })
+        .unwrap();
+        let actual = contains_initialize_with(&item_struct.attrs);
+        assert!(actual.is_none());
+    }
 }

borsh-derive/src/internals/attributes/item/snapshots/check_use_borsh_invalid_on_whole_struct.snap

@@ -2,4 +2,4 @@
 source: borsh-derive/src/internals/attributes/item/mod.rs
 expression: actual.unwrap_err().to_token_stream().to_string()
 ---
-:: core :: compile_error ! { "`use_discriminant` is the only supported attribute for `borsh`" }
+:: core :: compile_error ! { "`use_discriminant` or `init` are only supported attributes for `borsh`" }

borsh-derive/src/internals/attributes/item/snapshots/init_function_wrong_format.snap

@@ -0,0 +1,5 @@
+---
+source: borsh-derive/src/internals/attributes/item/mod.rs
+expression: actual.unwrap_err().to_token_stream().to_string()
+---
+:: core :: compile_error ! { "`use_discriminant` or `init` are only supported attributes for `borsh`" }

borsh-derive/src/internals/attributes/mod.rs

@@ -22,7 +22,7 @@ pub const DESERIALIZE: Symbol = Symbol("deserialize", "deserialize = ...");
 /// borsh_skip - field-level only attribute, `BorshSerialize`, `BorshDeserialize`, `BorshSchema` contexts
 pub const SKIP: Symbol = Symbol("borsh_skip", "borsh_skip");
 /// borsh_init - item-level only attribute  `BorshDeserialize` context
-pub const INIT: Symbol = Symbol("borsh_init", "borsh_init(...)");
+pub const INIT: Symbol = Symbol("init", "init(...)");
 /// serialize_with - sub-borsh nested meta, field-level only, `BorshSerialize` context
 pub const SERIALIZE_WITH: Symbol = Symbol("serialize_with", "serialize_with = ...");
 /// deserialize_with - sub-borsh nested meta, field-level only, `BorshDeserialize` context

borsh-derive/src/internals/deserialize/enums/mod.rs

@@ -364,4 +364,38 @@ mod tests {
 
         local_insta_assert_snapshot!(pretty_print_syn_str(&actual).unwrap());
     }
+    #[test]
+    fn borsh_init_func() {
+        let item_enum: ItemEnum = syn::parse2(quote! {
+            #[borsh(init = initializon_method, use_discriminant = true)]
+            enum A {
+                A,
+                B = 20,
+                C,
+                D,
+                E = 10,
+                F,
+            }
+        })
+        .unwrap();
+        let actual = process(&item_enum, Ident::new("borsh", Span::call_site())).unwrap();
+        local_insta_assert_snapshot!(pretty_print_syn_str(&actual).unwrap());
+    }
+    #[test]
+    fn borsh_init_func_reversed() {
+        let item_enum: ItemEnum = syn::parse2(quote! {
+            #[borsh(use_discriminant = true, init = initializon_method )]
+            enum A {
+                A,
+                B = 20,
+                C,
+                D,
+                E = 10,
+                F,
+            }
+        })
+        .unwrap();
+        let actual = process(&item_enum, Ident::new("borsh", Span::call_site())).unwrap();
+        local_insta_assert_snapshot!(pretty_print_syn_str(&actual).unwrap());
+    }
 }

borsh-derive/src/internals/deserialize/enums/snapshots/borsh_init_func.snap

@@ -0,0 +1,44 @@
+---
+source: borsh-derive/src/internals/deserialize/enums/mod.rs
+expression: pretty_print_syn_str(&actual).unwrap()
+---
+impl borsh::de::BorshDeserialize for A {
+    fn deserialize_reader<R: borsh::__private::maybestd::io::Read>(
+        reader: &mut R,
+    ) -> ::core::result::Result<Self, borsh::__private::maybestd::io::Error> {
+        let tag = <u8 as borsh::de::BorshDeserialize>::deserialize_reader(reader)?;
+        <Self as borsh::de::EnumExt>::deserialize_variant(reader, tag)
+    }
+}
+impl borsh::de::EnumExt for A {
+    fn deserialize_variant<R: borsh::__private::maybestd::io::Read>(
+        reader: &mut R,
+        variant_tag: u8,
+    ) -> ::core::result::Result<Self, borsh::__private::maybestd::io::Error> {
+        let mut return_value = if variant_tag == 0 {
+            A::A
+        } else if variant_tag == 20 {
+            A::B
+        } else if variant_tag == 20 + 1 {
+            A::C
+        } else if variant_tag == 20 + 1 + 1 {
+            A::D
+        } else if variant_tag == 10 {
+            A::E
+        } else if variant_tag == 10 + 1 {
+            A::F
+        } else {
+            return Err(
+                borsh::__private::maybestd::io::Error::new(
+                    borsh::__private::maybestd::io::ErrorKind::InvalidData,
+                    borsh::__private::maybestd::format!(
+                        "Unexpected variant tag: {:?}", variant_tag
+                    ),
+                ),
+            )
+        };
+        return_value.initializon_method();
+        Ok(return_value)
+    }
+}
+

borsh-derive/src/internals/deserialize/enums/snapshots/borsh_init_func_reversed.snap

@@ -0,0 +1,44 @@
+---
+source: borsh-derive/src/internals/deserialize/enums/mod.rs
+expression: pretty_print_syn_str(&actual).unwrap()
+---
+impl borsh::de::BorshDeserialize for A {
+    fn deserialize_reader<R: borsh::__private::maybestd::io::Read>(
+        reader: &mut R,
+    ) -> ::core::result::Result<Self, borsh::__private::maybestd::io::Error> {
+        let tag = <u8 as borsh::de::BorshDeserialize>::deserialize_reader(reader)?;
+        <Self as borsh::de::EnumExt>::deserialize_variant(reader, tag)
+    }
+}
+impl borsh::de::EnumExt for A {
+    fn deserialize_variant<R: borsh::__private::maybestd::io::Read>(
+        reader: &mut R,
+        variant_tag: u8,
+    ) -> ::core::result::Result<Self, borsh::__private::maybestd::io::Error> {
+        let mut return_value = if variant_tag == 0 {
+            A::A
+        } else if variant_tag == 20 {
+            A::B
+        } else if variant_tag == 20 + 1 {
+            A::C
+        } else if variant_tag == 20 + 1 + 1 {
+            A::D
+        } else if variant_tag == 10 {
+            A::E
+        } else if variant_tag == 10 + 1 {
+            A::F
+        } else {
+            return Err(
+                borsh::__private::maybestd::io::Error::new(
+                    borsh::__private::maybestd::io::ErrorKind::InvalidData,
+                    borsh::__private::maybestd::format!(
+                        "Unexpected variant tag: {:?}", variant_tag
+                    ),
+                ),
+            )
+        };
+        return_value.initializon_method();
+        Ok(return_value)
+    }
+}
+