Merge AzaleaRead and AzaleaWrite (#305)

3 files changed, 42 insertions, 105 deletions

diff --git a/azalea-buf/azalea-buf-macros/src/lib.rs b/azalea-buf/azalea-buf-macros/src/lib.rs
index 965e19c9..e71daf11 100644
--- a/azalea-buf/azalea-buf-macros/src/lib.rs
+++ b/azalea-buf/azalea-buf-macros/src/lib.rs
@@ -5,30 +5,6 @@ use proc_macro::TokenStream;
 use quote::quote;
 use syn::{DeriveInput, parse_macro_input};
 
-#[proc_macro_derive(AzaleaRead, attributes(var))]
-pub fn derive_azalearead(input: TokenStream) -> TokenStream {
-    let DeriveInput {
-        ident,
-        generics,
-        data,
-        ..
-    } = parse_macro_input!(input);
-
-    read::create_impl_azalearead(&ident, &generics, &data).into()
-}
-
-#[proc_macro_derive(AzaleaWrite, attributes(var))]
-pub fn derive_azaleawrite(input: TokenStream) -> TokenStream {
-    let DeriveInput {
-        ident,
-        generics,
-        data,
-        ..
-    } = parse_macro_input!(input);
-
-    write::create_impl_azaleawrite(&ident, &generics, &data).into()
-}
-
 #[proc_macro_derive(AzBuf, attributes(var, limit))]
 pub fn derive_azbuf(input: TokenStream) -> TokenStream {
     let DeriveInput {
@@ -38,11 +14,15 @@ pub fn derive_azbuf(input: TokenStream) -> TokenStream {
         ..
     } = parse_macro_input!(input);
 
-    let writable = write::create_impl_azaleawrite(&ident, &generics, &data);
-    let readable = read::create_impl_azalearead(&ident, &generics, &data);
+    let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
+
+    let writable = write::create_fn_azalea_write(&data);
+    let readable = read::create_fn_azalea_read(&data);
     quote! {
-        #writable
-        #readable
+        impl #impl_generics azalea_buf::AzBuf for #ident #ty_generics #where_clause {
+            #writable
+            #readable
+        }
     }
     .into()
 }
diff --git a/azalea-buf/azalea-buf-macros/src/read.rs b/azalea-buf/azalea-buf-macros/src/read.rs
index 9f4fa78a..7c8f1c9e 100644
--- a/azalea-buf/azalea-buf-macros/src/read.rs
+++ b/azalea-buf/azalea-buf-macros/src/read.rs
@@ -1,20 +1,13 @@
 use quote::{ToTokens, quote};
-use syn::{Data, Field, FieldsNamed, Generics, Ident, punctuated::Punctuated, token::Comma};
-
-pub fn create_impl_azalearead(
-    ident: &Ident,
-    generics: &Generics,
-    data: &Data,
-) -> proc_macro2::TokenStream {
-    let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
+use syn::{Data, Field, FieldsNamed, Ident, punctuated::Punctuated, token::Comma};
 
+pub fn create_fn_azalea_read(data: &Data) -> proc_macro2::TokenStream {
     match data {
         syn::Data::Struct(syn::DataStruct { fields, .. }) => match fields {
             syn::Fields::Named(FieldsNamed { named, .. }) => {
                 let (read_fields, read_field_names) = read_named_fields(named);
 
                 quote! {
-                impl #impl_generics azalea_buf::AzaleaRead for #ident #ty_generics #where_clause {
                     fn azalea_read(buf: &mut std::io::Cursor<&[u8]>) -> std::result::Result<Self, azalea_buf::BufReadError> {
                         #(#read_fields)*
                         Ok(Self {
@@ -22,29 +15,24 @@ pub fn create_impl_azalearead(
                         })
                     }
                 }
-                }
             }
             syn::Fields::Unit => {
                 quote! {
-                impl #impl_generics azalea_buf::AzaleaRead for #ident #ty_generics #where_clause {
                     fn azalea_read(buf: &mut std::io::Cursor<&[u8]>) -> std::result::Result<Self, azalea_buf::BufReadError> {
                         Ok(Self)
                     }
                 }
-                }
             }
             syn::Fields::Unnamed(fields) => {
                 let read_fields = read_unnamed_fields(&fields.unnamed);
 
                 quote! {
-                impl #impl_generics azalea_buf::AzaleaRead for #ident #ty_generics #where_clause {
                     fn azalea_read(buf: &mut std::io::Cursor<&[u8]>) -> std::result::Result<Self, azalea_buf::BufReadError> {
                         Ok(Self(
                             #(#read_fields),*
                         ))
                     }
                 }
-                }
             }
         },
         syn::Data::Enum(syn::DataEnum { variants, .. }) => {
@@ -81,7 +69,7 @@ pub fn create_impl_azalearead(
 
                         quote! {
                             #(#read_fields)*
-                            Ok(#ident::#variant_name {
+                            Ok(Self::#variant_name {
                                 #(#read_field_names: #read_field_names),*
                             })
                         }
@@ -98,7 +86,7 @@ pub fn create_impl_azalearead(
                                     .map(|a| {
                                         a.parse_args::<syn::LitInt>()
                                             .unwrap()
-                                            .base10_parse::<usize>()
+                                            .base10_parse::<u32>()
                                             .unwrap()
                                     });
 
@@ -108,15 +96,15 @@ pub fn create_impl_azalearead(
 
                             if is_variable_length {
                                 reader_code.extend(quote! {
-                                    Self::#variant_name(azalea_buf::AzaleaReadVar::azalea_read_var(buf)?),
+                                    Self::#variant_name(azalea_buf::AzBufVar::azalea_read_var(buf)?),
                                 });
                             } else if let Some(limit) = limit {
                                 reader_code.extend(quote! {
-                                    Self::#variant_name(azalea_buf::AzaleaReadLimited::azalea_read_limited(buf, #limit)?),
+                                    Self::#variant_name(azalea_buf::AzBufLimited::azalea_read_limited(buf, #limit)?),
                                 });
                             } else {
                                 reader_code.extend(quote! {
-                                    Self::#variant_name(azalea_buf::AzaleaRead::azalea_read(buf)?),
+                                    Self::#variant_name(azalea_buf::AzBuf::azalea_read(buf)?),
                                 });
                             }
                         }
@@ -141,15 +129,9 @@ pub fn create_impl_azalearead(
             let first_reader = first_reader.expect("There should be at least one variant");
 
             quote! {
-            impl #impl_generics azalea_buf::AzaleaRead for #ident #ty_generics #where_clause {
                 fn azalea_read(buf: &mut std::io::Cursor<&[u8]>) -> std::result::Result<Self, azalea_buf::BufReadError> {
-                    let id = azalea_buf::AzaleaReadVar::azalea_read_var(buf)?;
-                    Self::azalea_read_id(buf, id)
-                }
-            }
+                    let id = azalea_buf::AzBufVar::azalea_read_var(buf)?;
 
-            impl #impl_generics #ident #ty_generics #where_clause {
-                pub fn azalea_read_id(buf: &mut std::io::Cursor<&[u8]>, id: u32) -> std::result::Result<Self, azalea_buf::BufReadError> {
                     match id {
                         #match_contents
                         // you'd THINK this throws an error, but mojang decided to make it default for some reason
@@ -157,7 +139,6 @@ pub fn create_impl_azalearead(
                     }
                 }
             }
-            }
         }
         _ => panic!("#[derive(AzBuf)] can only be used on structs"),
     }
@@ -202,7 +183,7 @@ fn get_reader_call(f: &Field) -> proc_macro2::TokenStream {
         .map(|a| {
             a.parse_args::<syn::LitInt>()
                 .unwrap()
-                .base10_parse::<usize>()
+                .base10_parse::<u32>()
                 .unwrap()
         });
 
@@ -218,15 +199,15 @@ fn get_reader_call(f: &Field) -> proc_macro2::TokenStream {
         syn::Type::Path(_) | syn::Type::Array(_) => {
             if is_variable_length {
                 quote! {
-                    azalea_buf::AzaleaReadVar::azalea_read_var(buf)?
+                    azalea_buf::AzBufVar::azalea_read_var(buf)?
                 }
             } else if let Some(limit) = limit {
                 quote! {
-                    azalea_buf::AzaleaReadLimited::azalea_read_limited(buf, #limit)?
+                    azalea_buf::AzBufLimited::azalea_read_limited(buf, #limit)?
                 }
             } else {
                 quote! {
-                    azalea_buf::AzaleaRead::azalea_read(buf)?
+                    azalea_buf::AzBuf::azalea_read(buf)?
                 }
             }
         }
diff --git a/azalea-buf/azalea-buf-macros/src/write.rs b/azalea-buf/azalea-buf-macros/src/write.rs
index 7bd58d29..f7d7e07a 100644
--- a/azalea-buf/azalea-buf-macros/src/write.rs
+++ b/azalea-buf/azalea-buf-macros/src/write.rs
@@ -1,14 +1,8 @@
 use proc_macro2::Span;
 use quote::{ToTokens, quote};
-use syn::{Data, Field, FieldsNamed, Generics, Ident, punctuated::Punctuated, token::Comma};
-
-pub fn create_impl_azaleawrite(
-    ident: &Ident,
-    generics: &Generics,
-    data: &Data,
-) -> proc_macro2::TokenStream {
-    let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
+use syn::{Data, Field, FieldsNamed, Ident, punctuated::Punctuated, token::Comma};
 
+pub fn create_fn_azalea_write(data: &Data) -> proc_macro2::TokenStream {
     match data {
         syn::Data::Struct(syn::DataStruct { fields, .. }) => match fields {
             syn::Fields::Named(FieldsNamed { named, .. }) => {
@@ -16,20 +10,16 @@ pub fn create_impl_azaleawrite(
                     write_named_fields(named, Some(&Ident::new("self", Span::call_site())));
 
                 quote! {
-                    impl #impl_generics azalea_buf::AzaleaWrite for #ident #ty_generics #where_clause {
-                        fn azalea_write(&self, buf: &mut impl std::io::Write) -> std::result::Result<(), std::io::Error> {
-                            #write_fields
-                            Ok(())
-                        }
+                    fn azalea_write(&self, buf: &mut impl std::io::Write) -> std::result::Result<(), std::io::Error> {
+                        #write_fields
+                        Ok(())
                     }
                 }
             }
             syn::Fields::Unit => {
                 quote! {
-                    impl #impl_generics azalea_buf::AzaleaWrite for #ident #ty_generics #where_clause {
-                        fn azalea_write(&self, buf: &mut impl std::io::Write) -> std::result::Result<(), std::io::Error> {
-                            Ok(())
-                        }
+                    fn azalea_write(&self, buf: &mut impl std::io::Write) -> std::result::Result<(), std::io::Error> {
+                        Ok(())
                     }
                 }
             }
@@ -37,11 +27,9 @@ pub fn create_impl_azaleawrite(
                 let write_fields = write_unnamed_fields(&fields.unnamed);
 
                 quote! {
-                    impl #impl_generics azalea_buf::AzaleaWrite for #ident #ty_generics #where_clause {
-                        fn azalea_write(&self, buf: &mut impl std::io::Write) -> std::result::Result<(), std::io::Error> {
-                            #write_fields
-                            Ok(())
-                        }
+                    fn azalea_write(&self, buf: &mut impl std::io::Write) -> std::result::Result<(), std::io::Error> {
+                        #write_fields
+                        Ok(())
                     }
                 }
             }
@@ -83,7 +71,7 @@ pub fn create_impl_azaleawrite(
 
                 // the variant number that we're going to write
                 let write_the_variant = quote! {
-                    azalea_buf::AzaleaWriteVar::azalea_write_var(&#variant_discrim, buf)?;
+                    azalea_buf::AzBufVar::azalea_write_var(&#variant_discrim, buf)?;
                 };
                 match &variant.fields {
                     syn::Fields::Named(f) => {
@@ -125,11 +113,11 @@ pub fn create_impl_azaleawrite(
                             params_code.extend(quote! { #param_ident, });
                             if f.attrs.iter().any(|attr| attr.path().is_ident("var")) {
                                 writers_code.extend(quote! {
-                                    azalea_buf::AzaleaWriteVar::azalea_write_var(#param_ident, buf)?;
+                                    azalea_buf::AzBufVar::azalea_write_var(#param_ident, buf)?;
                                 });
                             } else {
                                 writers_code.extend(quote! {
-                                    azalea_buf::AzaleaWrite::azalea_write(#param_ident, buf)?;
+                                    azalea_buf::AzBuf::azalea_write(#param_ident, buf)?;
                                 });
                             }
                         }
@@ -141,7 +129,7 @@ pub fn create_impl_azaleawrite(
                         });
                         match_arms_without_id.extend(quote! {
                             Self::#variant_name(data) => {
-                                azalea_buf::AzaleaWrite::azalea_write(data, buf)?;
+                                azalea_buf::AzBuf::azalea_write(data, buf)?;
                             }
                         });
                     }
@@ -149,30 +137,18 @@ pub fn create_impl_azaleawrite(
             }
             if is_data_enum {
                 quote! {
-                    impl #impl_generics azalea_buf::AzaleaWrite for #ident #ty_generics #where_clause {
-                        fn azalea_write(&self, buf: &mut impl std::io::Write) -> std::result::Result<(), std::io::Error> {
-                            match self {
-                                #match_arms
-                            }
-                            Ok(())
-                        }
-                    }
-                    impl #impl_generics #ident #ty_generics #where_clause {
-                        pub fn write_without_id(&self, buf: &mut impl std::io::Write) -> std::result::Result<(), std::io::Error> {
-                            match self {
-                                #match_arms_without_id
-                            }
-                            Ok(())
+                    fn azalea_write(&self, buf: &mut impl std::io::Write) -> std::result::Result<(), std::io::Error> {
+                        match self {
+                            #match_arms
                         }
+                        Ok(())
                     }
                 }
             } else {
                 // optimization: if it doesn't have data we can just do `as u32`
                 quote! {
-                    impl #impl_generics azalea_buf::AzaleaWrite for #ident #ty_generics #where_clause {
-                        fn azalea_write(&self, buf: &mut impl std::io::Write) -> std::result::Result<(), std::io::Error> {
-                            azalea_buf::AzaleaWriteVar::azalea_write_var(&(*self as u32), buf)
-                        }
+                    fn azalea_write(&self, buf: &mut impl std::io::Write) -> std::result::Result<(), std::io::Error> {
+                        azalea_buf::AzBufVar::azalea_write_var(&(*self as u32), buf)
                     }
                 }
             }
@@ -218,11 +194,11 @@ fn make_write_call(
         syn::Type::Path(_) | syn::Type::Array(_) => {
             if f.attrs.iter().any(|attr| attr.path().is_ident("var")) {
                 quote! {
-                    azalea_buf::AzaleaWriteVar::azalea_write_var(#ident_dot_field, buf)?;
+                    azalea_buf::AzBufVar::azalea_write_var(#ident_dot_field, buf)?;
                 }
             } else {
                 quote! {
-                    azalea_buf::AzaleaWrite::azalea_write(#ident_dot_field, buf)?;
+                    azalea_buf::AzBuf::azalea_write(#ident_dot_field, buf)?;
                 }
             }
         }