borsh_derive_internal/
enum_de.rs

1use core::convert::TryFrom;
2
3use proc_macro2::TokenStream as TokenStream2;
4use quote::quote;
5use syn::{Fields, Ident, ItemEnum, WhereClause};
6
7use crate::attribute_helpers::{contains_initialize_with, contains_skip};
8
9pub fn enum_de(input: &ItemEnum, cratename: Ident) -> syn::Result<TokenStream2> {
10    let name = &input.ident;
11    let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
12    let mut where_clause = where_clause.map_or_else(
13        || WhereClause {
14            where_token: Default::default(),
15            predicates: Default::default(),
16        },
17        Clone::clone,
18    );
19    let init_method = contains_initialize_with(&input.attrs)?;
20    let mut variant_arms = TokenStream2::new();
21    for (variant_idx, variant) in input.variants.iter().enumerate() {
22        let variant_idx = u8::try_from(variant_idx).expect("up to 256 enum variants are supported");
23        let variant_ident = &variant.ident;
24        let mut variant_header = TokenStream2::new();
25        match &variant.fields {
26            Fields::Named(fields) => {
27                for field in &fields.named {
28                    let field_name = field.ident.as_ref().unwrap();
29                    if contains_skip(&field.attrs) {
30                        variant_header.extend(quote! {
31                            #field_name: Default::default(),
32                        });
33                    } else {
34                        let field_type = &field.ty;
35                        where_clause.predicates.push(
36                            syn::parse2(quote! {
37                                #field_type: #cratename::BorshDeserialize
38                            })
39                            .unwrap(),
40                        );
41
42                        variant_header.extend(quote! {
43                            #field_name: #cratename::BorshDeserialize::deserialize_reader(reader)?,
44                        });
45                    }
46                }
47                variant_header = quote! { { #variant_header }};
48            }
49            Fields::Unnamed(fields) => {
50                for field in fields.unnamed.iter() {
51                    if contains_skip(&field.attrs) {
52                        variant_header.extend(quote! { Default::default(), });
53                    } else {
54                        let field_type = &field.ty;
55                        where_clause.predicates.push(
56                            syn::parse2(quote! {
57                                #field_type: #cratename::BorshDeserialize
58                            })
59                            .unwrap(),
60                        );
61
62                        variant_header.extend(
63                            quote! { #cratename::BorshDeserialize::deserialize_reader(reader)?, },
64                        );
65                    }
66                }
67                variant_header = quote! { ( #variant_header )};
68            }
69            Fields::Unit => {}
70        }
71        variant_arms.extend(quote! {
72            #variant_idx => #name::#variant_ident #variant_header ,
73        });
74    }
75
76    let init = if let Some(method_ident) = init_method {
77        quote! {
78            return_value.#method_ident();
79        }
80    } else {
81        quote! {}
82    };
83
84    Ok(quote! {
85        impl #impl_generics #cratename::de::BorshDeserialize for #name #ty_generics #where_clause {
86            fn deserialize_reader<R: borsh::maybestd::io::Read>(reader: &mut R) -> ::core::result::Result<Self, #cratename::maybestd::io::Error> {
87                let tag = <u8 as #cratename::de::BorshDeserialize>::deserialize_reader(reader)?;
88                <Self as #cratename::de::EnumExt>::deserialize_variant(reader, tag)
89            }
90        }
91
92        impl #impl_generics #cratename::de::EnumExt for #name #ty_generics #where_clause {
93            fn deserialize_variant<R: borsh::maybestd::io::Read>(
94                reader: &mut R,
95                variant_idx: u8,
96            ) -> ::core::result::Result<Self, #cratename::maybestd::io::Error> {
97                let mut return_value = match variant_idx {
98                    #variant_arms
99                    _ => return Err(#cratename::maybestd::io::Error::new(
100                        #cratename::maybestd::io::ErrorKind::InvalidInput,
101                        #cratename::maybestd::format!("Unexpected variant index: {:?}", variant_idx),
102                    ))
103                };
104                #init
105                Ok(return_value)
106            }
107        }
108    })
109}
borsh_derive_internal/enum_de.rs

borsh_derive_internal/
enum_de.rs
