feat: use macro to define packets

Author: andybrwr

Cargo.lock

@@ -1,58 +1,6 @@
-# Copyright (c) 2024 Andrew Brower. 
-# This file is part of Crawlspace.
-#
-# Crawlspace is free software: you can redistribute it and/or
-# modify it under the terms of the GNU Affero General Public
-# License as published by the Free Software Foundation, either
-# version 3 of the License, or (at your option) any later version.
-#
-# Crawlspace is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Affero General Public License for more details.
-#
-# You should have received a copy of the GNU Affero General Public
-# License along with Crawlspace. If not, see
-# <https://www.gnu.org/licenses/>.
-
-[package]
-name = "crawlspace"
-version = "0.1.0"
-edition = "2021"
-license = "AGPL-3.0-or-later"
-
-[dependencies]
-aes = { version = "0.8.4", optional = true }
-bit-vec = "0.8.0"
-bitfield-struct = "0.9.2"
-byteorder = "1.5.0"
-bytes = "1.8.0"
-cfb8 = { version = "0.8.1", optional = true }
-clap = { version = "4.5.20", features = ["derive", "env"] }
-color-eyre = "0.6.3"
-fastanvil = { git = "https://github.com/owengage/fastnbt.git" }
-fastnbt = { git = "https://github.com/owengage/fastnbt.git" }
-rand = "0.8.5"
-rayon = "1.10.0"
-serde = { version = "1.0.213", features = ["derive"] }
-serde_json = "1.0.132"
-sha2 = "0.10.8"
-thiserror = "1.0.65"
-tokio = { version = "1.43.1", features = ["full"] }
-tokio-util = "0.7.12"
-tracing = { version = "0.1.40", features = ["max_level_trace", "release_max_level_info"] }
-tracing-subscriber = { version = "0.3.18", features = ["env-filter"] }
-uuid = "1.11.0"
-
-[features]
-default = []
-compression = []
-encryption = ["dep:cfb8", "dep:aes"]
-modern_art = []
-lan = []
-timings = []
-
-full = ["compression", "encryption"]
+[workspace]
+resolver = "2"
+members = [ "crawlspace-macro","crawlspace"]
 
 [profile.release-stripped]
 inherits = "release"

Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "crawlspace-macro"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+proc-macro = true
+
+[dependencies]
+quote = "1.0.40"
+syn = "2.0.104"

crawlspace-macro/Cargo.toml

@@ -0,0 +1,97 @@
+use proc_macro::{Span, TokenStream};
+use quote::quote;
+use syn::{parse_macro_input, DeriveInput, Ident, Lit};
+
+#[proc_macro_derive(Packet, attributes(packet))]
+pub fn derive_packet(input: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(input as DeriveInput);
+
+    let syn::Data::Struct(_) = input.data else {
+        panic!("Packet must be defined as a struct");
+    };
+
+    let mut id = None;
+    let mut state = None;
+    let mut direction = None;
+
+    for attr in input.attrs {
+        if !attr.path().is_ident("packet") {
+            continue;
+        }
+
+        attr.parse_nested_meta(|meta| {
+            if meta.path.is_ident("id") {
+                let lit = meta.value()?.parse()?;
+                match lit {
+                    Lit::Str(i) => {
+                        id = Some(i);
+                    }
+                    _ => panic!("attribute value `id` must be a string"),
+                }
+            } else if meta.path.is_ident("state") {
+                let lit = meta
+                    .value()
+                    .expect("no value for state")
+                    .parse()
+                    .expect("couldn't parse value for state");
+                let Lit::Str(v) = lit else {
+                    panic!("unable to parse state as string");
+                };
+                state = Some(
+                    v.parse_with(syn::Path::parse_mod_style)
+                        .expect("couldn't parse state as path"),
+                );
+            } else if meta.path.is_ident("serverbound") {
+                match direction {
+                    None => direction = Some("Serverbound"),
+                    Some(_) => {
+                        panic!("cannot have two directives of type `serverbound` or `clientbound`")
+                    }
+                }
+            } else if meta.path.is_ident("clientbound") {
+                match direction {
+                    None => direction = Some("Clientbound"),
+                    Some(_) => {
+                        panic!("cannot have two directives of type `serverbound` or `clientbound`")
+                    }
+                }
+            } else {
+                let Some(id) = meta.path.get_ident() else {
+                    panic!("unable to get ident for unrecognized directive");
+                };
+                panic!("unrecognized directive {}", id);
+            }
+
+            Ok(())
+        })
+        .unwrap();
+    }
+
+    let id = id.expect("id must be provided for packet");
+    let state = state.expect("state must be provided for packet");
+    let direction = Ident::new(
+        direction.expect("direction must be provided for packet"),
+        Span::call_site().into(),
+    );
+
+    let name = input.ident;
+    let where_clause = input.generics.where_clause.clone();
+    let generics = input.generics;
+
+    quote! {
+    impl #generics Packet for #name #generics #where_clause {
+        fn id() -> &'static str {
+            #id
+        }
+
+        fn state() -> PacketState {
+            #state
+        }
+
+        fn direction() -> PacketDirection {
+            PacketDirection::#direction
+        }
+    }
+    }
+    .into()
+}