Wesl macro

Cargo.toml

@@ -6,6 +6,8 @@ members = [
     "crates/wesl-test",
     "crates/wesl-web",
     "crates/wesl-cli",
+    "crates/tokrepr",
+    "crates/tokrepr-derive",
     "examples/random_wgsl",
     "examples/wesl-consumer",
 ]
@@ -24,6 +26,8 @@ rust-version = "1.86.0"
 wesl = { path = "crates/wesl", version = "0.1.2" }
 wesl-macros = { path = "crates/wesl-macros", version = "0.1.2" }
 wgsl-parse = { path = "crates/wgsl-parse", version = "0.1.2" }
+tokrepr = { path = "crates/tokrepr", version = "0.0.1" }
+tokrepr-derive = { path = "crates/tokrepr-derive", version = "0.0.1" }
 
 [workspace.lints.rust]
 

crates/tokrepr-derive/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "tokrepr-derive"
+description = "Derive macro for tokrepr"
+authors.workspace = true
+edition.workspace = true
+license.workspace = true
+repository.workspace = true
+version = "0.0.1"
+rust-version.workspace = true
+
+[dependencies]
+itertools = "0.14.0"
+proc-macro2 = "1.0.86"
+quote = "1.0.37"
+syn = "2.0.77"
+
+[lib]
+proc-macro = true
+
+[lints]
+workspace = true

crates/tokrepr-derive/src/lib.rs

@@ -0,0 +1,103 @@
+//! Derive macro for tokrepr.
+//!
+//!
+
+use itertools::Itertools;
+use proc_macro2::TokenStream;
+use quote::{format_ident, quote};
+use syn::{Data, DeriveInput, Fields, parse_macro_input};
+
+#[proc_macro_derive(TokRepr)]
+pub fn derive_tokrepr(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let input = parse_macro_input!(input as DeriveInput);
+    tokrepr_impl(input).into()
+}
+
+pub(crate) fn tokrepr_impl(input: DeriveInput) -> TokenStream {
+    let name = &input.ident;
+    let tokrepr_path = quote! { tokrepr };
+    let self_path = quote! {};
+
+    let body = match &input.data {
+        Data::Struct(data) => {
+            let fields = match &data.fields {
+                Fields::Named(fields) => {
+                    let fields = fields.named.iter().map(|f| &f.ident).collect_vec();
+                    quote! {
+                        #(let #fields = #tokrepr_path::TokRepr::tok_repr(&self.#fields);)*
+
+                        #tokrepr_path::quote::quote! {
+                            #self_path #name {
+                                #(#fields: # #fields,)*
+                            }
+                        }
+                    }
+                }
+                Fields::Unnamed(f) => {
+                    let fields = (0..f.unnamed.len())
+                        .map(|n| format_ident!("f{n}"))
+                        .collect_vec();
+
+                    quote! {
+                        #(let #fields = #tokrepr_path::TokRepr::tok_repr(#fields);)*
+
+                        #tokrepr_path::quote::quote!{
+                            #self_path #name(#(# #fields,)*)
+                        }
+                    }
+                }
+                Fields::Unit => {
+                    quote! {
+                        #tokrepr_path::quote::quote! {
+                            #self_path #name
+                        }
+                    }
+                }
+            };
+            fields
+        }
+        Data::Enum(data) => {
+            let fields = data.variants.iter().map(|v| {
+                let variant = &v.ident;
+                match &v.fields {
+                    Fields::Named(_) => unimplemented!(),
+                    Fields::Unnamed(f) => {
+                        let fields = (0..f.unnamed.len())
+                            .map(|n| format_ident!("f{n}"))
+                            .collect_vec();
+
+                        quote! {
+                            Self::#variant(#(#fields),*) => {
+                                #(let #fields = #tokrepr_path::TokRepr::tok_repr(#fields);)*
+
+                                #tokrepr_path::quote::quote!{
+                                    #self_path #name::#variant(#(# #fields,)*)
+                                }
+                            }
+                        }
+                    },
+                    Fields::Unit => {
+                        quote! {
+                            Self::#variant => #tokrepr_path::quote::quote! { #self_path #name::#variant }
+                        }
+                    },
+                }
+            });
+
+            quote! {
+                match self {
+                    #(#fields,)*
+                }
+            }
+        }
+        Data::Union(_) => unimplemented!("tokrepr derive is not implemented for unions"),
+    };
+
+    quote! {
+        impl #tokrepr_path::TokRepr for #name {
+            fn tok_repr(&self) -> #tokrepr_path::proc_macro2::TokenStream {
+                #body
+            }
+        }
+    }
+}

crates/tokrepr/Cargo.toml

@@ -0,0 +1,22 @@
+[package]
+name = "tokrepr"
+description = "Turn Rust instances into token representations"
+authors.workspace = true
+edition.workspace = true
+license.workspace = true
+repository.workspace = true
+version = "0.0.1"
+rust-version.workspace = true
+
+[dependencies]
+proc-macro2 = "1.0.86"
+quote = "1.0.37"
+tokrepr-derive = { workspace = true, optional = true }
+
+[features]
+default = ["derive"]
+derive = ["dep:tokrepr-derive"]
+rc = []
+
+[lints]
+workspace = true