Derive macro generation

Question

I'm making my own Serializable trait, in the context of a client / server system. My idea was that the messages sent by the system is an enum made by the user of this system, so it can be customize as needed.

Too ease implementing the trait on the enum, I would like to use the #[derive(Serializable)] method, as implementing it is always the same thing.

Here is the trait :

pub trait NetworkSerializable {
    fn id(&self) -> usize;
    fn size(&self) -> usize;
    fn serialize(self) -> Vec<u8>;
    fn deserialize(id: usize, data: Vec<u8>) -> Self;
}

Now, I've tried to look at the book (this one too) and this example to try to wrap my head around derive macros, but I'm really struggling to understand them and how to implement them. I've read about token streams and abstract trees, and I think I understand the basics.

Let's take the example of the id() method : it should gives a unique id for each variant of the enum, to allow headers of messages to tell which message is incoming.

let's say I have this enum as a message system :

enum NetworkMessages {
    ErrorMessage,
    SpawnPlayer(usize, bool, Transform), // player id, is_mine, position
    MovePlayer(usize, Transform), // player id, new_position
    DestroyPlayer(usize) // player_id
}

Then, the id() function should look like this :

fn id(&self) -> usize {
    match &self {
        &ErrorMessage => 0,
        &SpawnPlayer => 1,
        &MovePlayer => 2,
        &DestroyPlayer => 3,
    }
}

Here was my go with writting this using a derive macro :

#[proc_macro_derive(NetworkSerializable)]
pub fn network_serializable_derive(input: TokenStream) -> TokenStream {
    // Construct a representation of Rust code as a syntax tree
    // that we can manipulate
    let ast = syn::parse(input).unwrap();

    // Build the trait implementation
    impl_network_serializable_macro(&ast)
}


fn impl_network_serializable_macro(ast: &syn::DeriveInput) -> TokenStream {
    
    // get enum name
    let ref name = ast.ident;
    let ref data = ast.data;

    let (id_func, size_func, serialize_func, deserialize_func) = match data {
        // Only if data is an enum, we do parsing
        Data::Enum(data_enum) => {

            // Iterate over enum variants

            let mut id_func_internal = TokenStream2::new();
            let mut variant_id: usize = 0;

            for variant in &data_enum.variants {

                // add the branch for the variant
                id_func_internal.extend(quote_spanned!{
                    variant.span() => &variant_id,
                });
                variant_id += 1;
            }

            
            (id_func_internal, (), (), ())
        }
        _ => {(TokenStream2::new(), (), (), ())},
    };

    let expanded = quote! {
        impl NetworkSerializable for #name {
            // variant_checker_functions gets replaced by all the functions
            // that were constructed above
            fn size(&self) -> usize {
                match &self {
                    #id_func
                }
            }
            /*
            #size_func
            #serialize_func
            #deserialize_func
            */
        }
    };

    expanded.into()
}

So this is generating quite a lot of errors, with the "proc macro NetworkSerializable not expanded: no proc macro dylib present" being first. So I'm guessing there a lot of misunderstaning from my part in here.