1use proc_macro::TokenStream;
2use proc_macro2::{Ident, Span};
3use quote::{format_ident, quote};
4use syn::{DeriveInput, GenericParam, Lifetime, LifetimeParam, TypeParam};
5
6pub fn fake_encode(input: TokenStream) -> TokenStream {
7    let input: DeriveInput = syn::parse(input).expect("Unable to parse input");
8
9    let (impl_generics, type_generics, where_clause) = input.generics.split_for_impl();
10
11    let type_ident = &input.ident;
12    let expanded = quote! {
13        impl #impl_generics ::bincode::Encode for #type_ident #type_generics #where_clause {
14            fn encode<E: ::bincode::enc::Encoder>(
15                &self,
16                _encoder: &mut E
17            ) -> ::std::result::Result<(), ::bincode::error::EncodeError> {
18                ::std::result::Result::Ok(())
19            }
20        }
21    };
22
23    expanded.into()
24}
25
26pub fn fake_decode(input: TokenStream) -> TokenStream {
27    let input: DeriveInput = syn::parse(input).expect("Unable to parse input");
28
29    let (_, type_generics, where_clause) = input.generics.split_for_impl();
30
31    let mut decode_generics = input.generics.clone();
32    decode_generics.params.insert(0, GenericParam::Type(TypeParam::from(format_ident!("Context"))));
33    let (decode_impl_generics, _, _) = decode_generics.split_for_impl();
34
35    let mut borrow_generics = input.generics.clone();
36    borrow_generics
37        .params
38        .insert(0, GenericParam::Type(TypeParam::from(Ident::new("Context", Span::call_site()))));
39    borrow_generics.params.insert(
40        0,
41        GenericParam::Lifetime(LifetimeParam::new(Lifetime::new("'de", Span::call_site()))),
42    );
43    let (borrow_impl_generics, _, _) = borrow_generics.split_for_impl();
44
45    let type_ident = &input.ident;
46    let expanded = quote! {
47        impl #decode_impl_generics ::bincode::Decode<Context> for #type_ident #type_generics #where_clause {
48            fn decode<D: ::bincode::de::Decoder<Context = Context>>(
49                _decoder: &mut D
50            ) -> ::std::result::Result<Self, ::bincode::error::DecodeError> {
51                ::std::result::Result::Ok(Self::default())
52            }
53        }
54
55        impl #borrow_impl_generics ::bincode::BorrowDecode<'de, Context> for #type_ident #type_generics #where_clause {
56            fn borrow_decode<D: ::bincode::de::BorrowDecoder<'de, Context = Context>>(
57                _decoder: &mut D
58            ) -> ::std::result::Result<Self, ::bincode::error::DecodeError> {
59                ::std::result::Result::Ok(Self::default())
60            }
61        }
62    };
63
64    expanded.into()
65}