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

@@ -14,10 +14,10 @@ pub fn check_item_attributes(derive_input: &DeriveInput) -> Result<(), TokenStre
         }
         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.is_ident(INIT.0) {
                     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 +29,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(())
             })
@@ -68,6 +71,9 @@ pub fn contains_use_discriminant(input: &ItemEnum) -> Result<bool, syn::Error> {
                     };
                 }
 
+                if meta.path.is_ident(INIT.0) {
+                    let _value_expr: Expr = meta.value()?.parse()?;
+                }
                 Ok(())
             })?;
         }
@@ -86,18 +92,22 @@ pub fn contains_use_discriminant(input: &ItemEnum) -> Result<bool, syn::Error> {
 }
 
 pub(crate) fn contains_initialize_with(attrs: &[Attribute]) -> Option<Path> {
+    let mut res = None;
     for attr in attrs.iter() {
-        if attr.path() == INIT {
-            let mut res = None;
+        if attr.path() == BORSH {
             let _ = attr.parse_nested_meta(|meta| {
-                res = Some(meta.path);
+                if meta.path.is_ident(INIT.0) {
+                    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(())
             });
-            return res;
         }
     }
 
-    None
+    res
 }
 
 #[cfg(test)]
@@ -199,4 +209,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 = initializonsdfasfsa)]
+        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 = initializonsdfasfsa)]
+        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 = initializonsdfasfsa)]
+        struct A<'a> {
+            x: u64,
+        }
+                })
+        .unwrap();
+
+        let actual = contains_initialize_with(&item_struct.attrs);
+        assert_eq!(
+            actual.unwrap().to_token_stream().to_string(),
+            "initializonsdfasfsa"
+        );
+    }
+
+    #[test]
+    fn test_contains_initialize_with_function_wrong_format() {
+        let item_struct: DeriveInput = syn::parse2(quote! {
+        #[derive(BorshDeserialize, Debug)]
+        #[borsh(init_func = initializonsdfasfsa)]
+        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(initializonsdfasfsa)]
+        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)
+    }
+}
+

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

@@ -294,4 +294,17 @@ mod tests {
 
         local_insta_assert_snapshot!(pretty_print_syn_str(&actual).unwrap());
     }
+    #[test]
+    fn borsh_init_func() {
+        let item_enum: ItemStruct = syn::parse2(quote! {
+            #[borsh(init=initializon_method)]
+            struct A {
+                x: u64,
+                y: String,
+            }
+        })
+        .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/structs/snapshots/borsh_init_func.snap

@@ -0,0 +1,17 @@
+---
+source: borsh-derive/src/internals/deserialize/structs/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 mut return_value = Self {
+            x: borsh::BorshDeserialize::deserialize_reader(reader)?,
+            y: borsh::BorshDeserialize::deserialize_reader(reader)?,
+        };
+        return_value.initializon_method();
+        Ok(return_value)
+    }
+}
+

borsh-derive/src/lib.rs

@@ -303,12 +303,12 @@ Attribute's value is syn's [Path](syn::Path)-s, enclosed in parentheses.
 
 ###### usage
 
-`#[borsh_init(...)]` allows to automatically run an initialization function right after deserialization.
+`#[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.
 
 ```ignore
 #[derive(BorshDeserialize)]
-#[borsh_init(init)]
+#[borsh(init=init)]
 struct Message {
     message: String,
     timestamp: u64,
@@ -520,7 +520,7 @@ enum X {
 ```
 
 */
-#[proc_macro_derive(BorshDeserialize, attributes(borsh_skip, borsh_init, borsh))]
+#[proc_macro_derive(BorshDeserialize, attributes(borsh_skip, borsh))]
 pub fn borsh_deserialize(input: TokenStream) -> TokenStream {
     let name = &crate_name("borsh").unwrap();
     let name = match name {

borsh/tests/snapshots/test_simple_structs__simple_enum.snap

@@ -0,0 +1,7 @@
+---
+source: borsh/tests/test_simple_structs.rs
+expression: encoded_a
+---
+[
+    1,
+]