feat(jsgc-derive): add jsgc-derive

libs/jsgc-derive/Cargo.toml

@@ -0,0 +1,27 @@
+[package]
+name = "jsgc-derive"
+authors.workspace = true
+edition.workspace = true
+homepage.workspace = true
+license.workspace = true
+publish.workspace = true
+repository.workspace = true
+rust-version.workspace = true
+version.workspace = true
+
+[dependencies]
+base = { path = "../base" }
+proc-macro2 = "1.0.106"
+quote = "1.0.45"
+syn = { version = "2.0.117", features = ["extra-traits"] }
+
+[dev-dependencies]
+jsgc = { path = "../jsgc" }
+trybuild = "1.0.116"
+
+[lints]
+workspace = true
+
+[lib]
+bench = false
+proc-macro = true

libs/jsgc-derive/README.md

@@ -0,0 +1,3 @@
+# jsgc-derive
+
+> Implementation of `derive(Trace)`

libs/jsgc-derive/src/lib.rs

@@ -0,0 +1,99 @@
+#[proc_macro_derive(Trace)]
+pub fn derive_trace(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let input = syn::parse_macro_input!(input as syn::DeriveInput);
+    do_derive_trace(input).into()
+}
+
+fn do_derive_trace(input: syn::DeriveInput) -> proc_macro2::TokenStream {
+    let ty_name = &input.ident;
+    let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
+
+    let body = trace_fields(&input.data);
+
+    if body.is_empty() {
+        quote::quote! {
+            impl #impl_generics jsgc::Trace for #ty_name #ty_generics #where_clause {
+                #[inline]
+                fn trace(&self, _visits: &mut jsgc::VisitList) {}
+            }
+        }
+    } else {
+        quote::quote! {
+            impl #impl_generics jsgc::Trace for #ty_name #ty_generics #where_clause {
+                #[inline]
+                fn trace(&self, visits: &mut jsgc::VisitList) {
+                    #body
+                }
+            }
+        }
+    }
+}
+
+fn trace_fields(data: &syn::Data) -> proc_macro2::TokenStream {
+    match *data {
+        syn::Data::Struct(ref data) => match data.fields {
+            syn::Fields::Named(ref fields) => {
+                let recurse = fields.named.iter().map(|f| {
+                    let name = &f.ident;
+                    quote::quote! {
+                        self.#name.trace(visits);
+                    }
+                });
+                quote::quote! {
+                    #(#recurse)*
+                }
+            }
+            syn::Fields::Unnamed(_) => unimplemented!("unnamed fields are not supported yet"),
+            syn::Fields::Unit => quote::quote!(),
+        },
+        syn::Data::Enum(_) => unimplemented!("enums are not supported yet"),
+        syn::Data::Union(_) => unreachable!("unions are not sypported"),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_struct() {
+        let input: syn::DeriveInput = syn::parse_quote! {
+            struct Simple {
+                string: Handle<String>,
+                object: HandleMut<Object>,
+            }
+        };
+
+        let actual = do_derive_trace(input);
+
+        let expected = quote::quote! {
+            impl jsgc::Trace for Simple {
+                #[inline]
+                fn trace(&self, visits: &mut jsgc::VisitList) {
+                    self.string.trace(visits);
+                    self.object.trace(visits);
+                }
+            }
+        };
+
+        assert_eq!(actual.to_string(), expected.to_string());
+    }
+
+    #[test]
+    fn test_unit() {
+        let input: syn::DeriveInput = syn::parse_quote! {
+            struct Unit;
+        };
+
+        let actual = do_derive_trace(input);
+
+        let expected = quote::quote! {
+            impl jsgc::Trace for Unit {
+                #[inline]
+                fn trace(&self, _visits: &mut jsgc::VisitList) {}
+            }
+        };
+
+        assert_eq!(actual.to_string(), expected.to_string());
+    }
+}

libs/jsgc-derive/tests/pass/boxed.rs

@@ -0,0 +1,15 @@
+use jsgc::Handle;
+use jsgc_derive::Trace;
+
+#[derive(Trace)]
+struct A {
+    handle: Handle<u8>,
+}
+
+#[derive(Trace)]
+struct B {
+    a: Box<A>,
+    b: Box<dyn jsgc::Trace>,
+}
+
+fn main() {}

libs/jsgc-derive/tests/pass/option.rs

@@ -0,0 +1,14 @@
+use jsgc::Handle;
+use jsgc_derive::Trace;
+
+#[derive(Trace)]
+struct A {
+    handle: Handle<u8>,
+}
+
+#[derive(Trace)]
+struct B {
+    a: Option<A>,
+}
+
+fn main() {}

libs/jsgc-derive/tests/pass/primitive.rs

@@ -0,0 +1,24 @@
+use jsgc_derive::Trace;
+
+#[derive(Trace)]
+struct A {
+    t_unit: (),
+    t_bool: bool,
+    t_char: char,
+    t_f32: f32,
+    t_f64: f64,
+    t_i8: i8,
+    t_i16: i16,
+    t_i32: i32,
+    t_i64: i64,
+    t_i128: i128,
+    t_isize: isize,
+    t_u8: u8,
+    t_u16: u16,
+    t_u32: u32,
+    t_u64: u64,
+    t_u128: u128,
+    t_usize: usize,
+}
+
+fn main() {}

libs/jsgc-derive/tests/pass/ref.rs

@@ -0,0 +1,25 @@
+use jsgc_derive::Trace;
+
+#[derive(Trace)]
+struct A<'a> {
+    t_unit: &'a (),
+    t_bool: &'a bool,
+    t_char: &'a char,
+    t_f32: &'a f32,
+    t_f64: &'a f64,
+    t_i8: &'a i8,
+    t_i16: &'a i16,
+    t_i32: &'a i32,
+    t_i64: &'a i64,
+    t_i128: &'a i128,
+    t_isize: &'a isize,
+    t_str: &'a str,
+    t_u8: &'a u8,
+    t_u16: &'a u16,
+    t_u32: &'a u32,
+    t_u64: &'a u64,
+    t_u128: &'a u128,
+    t_usize: &'a usize,
+}
+
+fn main() {}

libs/jsgc-derive/tests/pass/result.rs

@@ -0,0 +1,19 @@
+use jsgc::Handle;
+use jsgc_derive::Trace;
+
+#[derive(Trace)]
+struct A {
+    handle: Handle<u8>,
+}
+
+#[derive(Trace)]
+struct B {
+    handle: Handle<u8>,
+}
+
+#[derive(Trace)]
+struct C {
+    result: Result<A, B>,
+}
+
+fn main() {}