Merge pull request #355 from koto-lang/generic-derive-macros

Add support for generic types in the derive macros

CHANGELOG.md

@@ -26,6 +26,13 @@ The Koto project adheres to
 
 - `tuple.sort_copy` now supports sorting with a key function, like `list.sort`.
 
+#### API
+
+- Improved support for generic `KotoObject` types
+  - The macros in `koto_derive` have been updated to support generics.
+    - `KotoField` has been added to reduce boilerplate when using the derive
+      macros.
+
 ### Changed
 
 #### Language

crates/derive/Cargo.toml

@@ -12,6 +12,12 @@ keywords = ["scripting", "language", "koto"]
 [lib]
 proc-macro = true
 
+[features]
+default = ["arc"]
+# One memory management scheme can be enabled at a time
+arc = []
+rc = []
+
 [dependencies]
 proc-macro2 = { workspace = true }
 quote = { workspace = true }

crates/derive/src/koto_copy.rs

@@ -5,18 +5,32 @@ use syn::{parse_macro_input, DeriveInput};
 
 pub(crate) fn derive_koto_copy(input: TokenStream) -> TokenStream {
     let input = parse_macro_input!(input as DeriveInput);
-    let attributes = koto_derive_attributes(&input.attrs);
+    let name = input.ident;
+    let (impl_generics, ty_generics, generic_where_clause) = input.generics.split_for_impl();
 
+    let attributes = koto_derive_attributes(&input.attrs);
     let (required_trait, copy_impl) = if attributes.use_copy {
         (quote! {Copy}, quote! {(*self).into()})
     } else {
         (quote! {Clone}, quote! {self.clone().into()})
     };
 
-    let name = input.ident;
+    let object_where_clause = quote! { #name #ty_generics: KotoObject + #required_trait };
+    let where_clause = if let Some(generic_where_clause) = generic_where_clause {
+        if generic_where_clause.predicates.trailing_punct() {
+            quote! { #generic_where_clause #object_where_clause }
+        } else {
+            quote! { #generic_where_clause, #object_where_clause }
+        }
+    } else {
+        quote! { where #object_where_clause }
+    };
+
     let result = quote! {
         #[automatically_derived]
-        impl KotoCopy for #name where #name: #required_trait {
+        impl #impl_generics KotoCopy for #name #ty_generics
+            #where_clause
+        {
             fn copy(&self) -> KObject {
                 #copy_impl
             }