feat: zero-copy-derive

Author: ananas-block

Cargo.toml

@@ -13,6 +13,7 @@ members = [
     "program-libs/hash-set",
     "program-libs/indexed-merkle-tree",
     "program-libs/indexed-array",
+    "program-libs/zero-copy-derive",
     "programs/account-compression",
     "programs/system",
     "programs/compressed-token",

program-libs/zero-copy-derive/Cargo.toml

@@ -0,0 +1,22 @@
+[package]
+name = "light-zero-copy-derive"
+version = "0.1.0"
+edition = "2021"
+license = "Apache-2.0"
+description = "Proc macro for zero-copy deserialization"
+
+[lib]
+proc-macro = true
+
+[dependencies]
+proc-macro2 = "1.0"
+quote = "1.0"
+syn = { version = "2.0", features = ["full", "extra-traits"] }
+lazy_static = "1.4"
+
+[dev-dependencies]
+trybuild = "1.0"
+rand = "0.8"
+borsh = { workspace = true }
+light-zero-copy = { workspace = true, features = ["std"] }
+zerocopy = { workspace = true, features = ["derive"] }

program-libs/zero-copy-derive/README.md

@@ -0,0 +1,103 @@
+# Light-Zero-Copy-Derive
+
+A procedural macro for deriving zero-copy deserialization for Rust structs used with Solana programs.
+
+## Features
+
+This crate provides two key derive macros:
+
+1. `#[derive(ZeroCopy)]` - Implements zero-copy deserialization with:
+   - The `zero_copy_at` and `zero_copy_at_mut` methods for deserialization
+   - Full Borsh compatibility for serialization/deserialization
+   - Efficient memory representation with no copying of data
+   - `From<Z<StructName>>` and `From<Z<StructName>Mut>` implementations for easy conversion back to the original struct
+
+2. `#[derive(ZeroCopyEq)]` - Adds equality comparison support:
+   - Compare zero-copy instances with regular struct instances
+   - Can be used alongside `ZeroCopy` for complete functionality
+   - Derivation for Options<struct> is not robust and may not compile.
+
+## Rules for Zero-Copy Deserialization
+
+The macro follows these rules when generating code:
+
+1. Creates a `ZStruct` for your struct that follows zero-copy principles
+   1. Fields are extracted into a meta struct until reaching a `Vec`, `Option` or non-`Copy` type
+   2. Vectors are represented as `ZeroCopySlice` and not included in the meta struct
+   3. Integer types are replaced with their zerocopy equivalents (e.g., `u16` → `U16`)
+   4. Fields after the first vector are directly included in the `ZStruct` and deserialized one by one
+   5. If a vector contains a nested vector (non-`Copy` type), it must implement `Deserialize`
+   6. Elements in an `Option` must implement `Deserialize`
+   7. Types that don't implement `Copy` must implement `Deserialize` and are deserialized one by one
+
+## Usage
+
+### Basic Usage
+
+```rust
+use borsh::{BorshDeserialize, BorshSerialize};
+use light_zero_copy_derive::ZeroCopy;
+use light_zero_copy::{borsh::Deserialize, borsh_mut::DeserializeMut};
+
+#[repr(C)]
+#[derive(Debug, PartialEq, BorshSerialize, BorshDeserialize, ZeroCopy)]
+pub struct MyStruct {
+    pub a: u8,
+    pub b: u16,
+    pub vec: Vec<u8>,
+    pub c: u64,
+}
+let my_struct = MyStruct {
+    a: 1,
+    b: 2,
+    vec: vec![1u8; 32],
+    c: 3,
+};
+// Use the struct with zero-copy deserialization
+let mut bytes = my_struct.try_to_vec().unwrap();
+
+// Immutable zero-copy deserialization
+let (zero_copy, _remaining) = MyStruct::zero_copy_at(&bytes).unwrap();
+
+// Convert back to original struct using From implementation
+let converted: MyStruct = zero_copy.clone().into();
+assert_eq!(converted, my_struct);
+
+// Mutable zero-copy deserialization with modification
+let (mut zero_copy_mut, _remaining) = MyStruct::zero_copy_at_mut(&mut bytes).unwrap();
+zero_copy_mut.a = 42;
+
+// The change is reflected when we convert back to the original struct
+let modified: MyStruct = zero_copy_mut.into();
+assert_eq!(modified.a, 42);
+
+// And also when we deserialize directly from the modified bytes
+let borsh = MyStruct::try_from_slice(&bytes).unwrap();
+assert_eq!(borsh.a, 42u8);
+```
+
+### With Equality Comparison
+
+```rust
+use borsh::{BorshDeserialize, BorshSerialize};
+use light_zero_copy_derive::ZeroCopy;
+
+#[repr(C)]
+#[derive(Debug, PartialEq, BorshSerialize, BorshDeserialize, ZeroCopy)]
+pub struct MyStruct {
+    pub a: u8,
+    pub b: u16,
+    pub vec: Vec<u8>,
+    pub c: u64,
+}
+let my_struct = MyStruct {
+    a: 1,
+    b: 2,
+    vec: vec![1u8; 32],
+    c: 3,
+};
+// Use the struct with zero-copy deserialization
+let mut bytes = my_struct.try_to_vec().unwrap();
+let (zero_copy, _remaining) = MyStruct::zero_copy_at(&bytes).unwrap();
+assert_eq!(zero_copy, my_struct);
+```

program-libs/zero-copy-derive/src/byte_len.rs

@@ -0,0 +1,204 @@
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::{Field, Ident};
+
+use crate::{
+    utils,
+    z_struct::{analyze_struct_fields, FieldType},
+};
+
+/// Generates byte_len implementation for DeserializeMut trait
+///
+/// RULES AND EXCEPTIONS FROM borsh_mut.rs:
+///
+/// DEFAULT RULE: Call byte_len() on each field and sum the results
+///
+/// EXCEPTIONS:
+/// 1. Boolean fields: Use core::mem::size_of::<u8>() (1 byte) instead of byte_len()
+///    * See line 97 where booleans use a special case
+///
+/// NOTES ON TYPE-SPECIFIC IMPLEMENTATIONS:
+/// * Primitive types: self.field.byte_len() delegates to size_of::<T>()
+///   - u8, u16, u32, u64, etc. all use size_of::<T>() in their implementations
+///   - See implementations in lines 88-90, 146-148, and macro in lines 135-151
+///
+/// * Arrays [T; N]: use size_of::<Self>() in implementation (line 41)
+///
+/// * Vec<T>: 4 bytes for length prefix + sum of byte_len() for each element
+///   - The Vec implementation in line 131 is: 4 + self.iter().map(|t| t.byte_len()).sum::<usize>()
+///   - Special case in Struct4 (line 650-657): explicitly sums the byte_len of each item
+///
+/// * VecU8<T>: Uses 1 byte for length prefix instead of regular Vec's 4 bytes
+///   - Implementation in line 205 shows: 1 + size_of::<T>()
+///
+/// * Option<T>: 1 byte for discriminator + value's byte_len if Some, or just 1 byte if None
+///   - See implementation in lines 66-72
+///
+/// * Fixed-size types: Generally implement as their own fixed size
+///   - Pubkey (line 45-46): hard-coded as 32 bytes
+pub fn generate_byte_len_impl<'a>(
+    _name: &Ident,
+    meta_fields: &'a [&'a Field],
+    struct_fields: &'a [&'a Field],
+) -> TokenStream {
+    let field_types = analyze_struct_fields(struct_fields);
+
+    // Generate statements for calculating byte_len for each field
+    let meta_byte_len = if !meta_fields.is_empty() {
+        meta_fields
+            .iter()
+            .map(|field| {
+                let field_name = &field.ident;
+                // Handle boolean fields specially by using size_of instead of byte_len
+                if utils::is_bool_type(&field.ty) {
+                    quote! { core::mem::size_of::<u8>() }
+                } else {
+                    quote! { self.#field_name.byte_len() }
+                }
+            })
+            .reduce(|acc, item| {
+                quote! { #acc + #item }
+            })
+    } else {
+        None
+    };
+
+    // Generate byte_len calculations for struct fields
+    // Default rule: Use self.field.byte_len() for all fields
+    // Exception: Use core::mem::size_of::<u8>() for boolean fields
+    let struct_byte_len = field_types.into_iter().map(|field_type| {
+        match field_type {
+            // Exception 1: Booleans use size_of::<u8>() directly
+            FieldType::Bool(_) | FieldType::CopyU8Bool(_) => {
+                quote! { core::mem::size_of::<u8>() }
+            }
+            // All other types delegate to their own byte_len implementation
+            FieldType::VecU8(field_name)
+            | FieldType::VecCopy(field_name, _)
+            | FieldType::VecNonCopy(field_name, _)
+            | FieldType::Array(field_name, _)
+            | FieldType::Option(field_name, _)
+            | FieldType::Pubkey(field_name)
+            | FieldType::IntegerU64(field_name)
+            | FieldType::IntegerU32(field_name)
+            | FieldType::IntegerU16(field_name)
+            | FieldType::IntegerU8(field_name)
+            | FieldType::Copy(field_name, _)
+            | FieldType::NonCopy(field_name, _) => {
+                quote! { self.#field_name.byte_len() }
+            }
+        }
+    });
+
+    // Combine meta fields and struct fields for total byte_len calculation
+    let combined_byte_len = match meta_byte_len {
+        Some(meta) => {
+            let struct_bytes = struct_byte_len.fold(quote!(), |acc, item| {
+                if acc.is_empty() {
+                    item
+                } else {
+                    quote! { #acc + #item }
+                }
+            });
+
+            if struct_bytes.is_empty() {
+                meta
+            } else {
+                quote! { #meta + #struct_bytes }
+            }
+        }
+        None => struct_byte_len.fold(quote!(), |acc, item| {
+            if acc.is_empty() {
+                item
+            } else {
+                quote! { #acc + #item }
+            }
+        }),
+    };
+
+    // Generate the final implementation
+    quote! {
+        fn byte_len(&self) -> usize {
+            #combined_byte_len
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use quote::format_ident;
+    use syn::parse_quote;
+
+    use super::*;
+
+    #[test]
+    fn test_generate_byte_len_simple() {
+        let name = format_ident!("TestStruct");
+
+        let field1: Field = parse_quote!(pub a: u8);
+        let field2: Field = parse_quote!(pub b: u16);
+
+        let meta_fields = vec![&field1, &field2];
+        let struct_fields: Vec<&Field> = vec![];
+
+        let result = generate_byte_len_impl(&name, &meta_fields, &struct_fields);
+        let result_str = result.to_string();
+
+        assert!(result_str.contains("fn byte_len (& self) -> usize"));
+        assert!(result_str.contains("self . a . byte_len () + self . b . byte_len ()"));
+    }
+
+    #[test]
+    fn test_generate_byte_len_with_vec() {
+        let name = format_ident!("TestStruct");
+
+        let field1: Field = parse_quote!(pub a: u8);
+        let field2: Field = parse_quote!(pub vec: Vec<u8>);
+        let field3: Field = parse_quote!(pub c: u32);
+
+        let meta_fields = vec![&field1];
+        let struct_fields = vec![&field2, &field3];
+
+        let result = generate_byte_len_impl(&name, &meta_fields, &struct_fields);
+        let result_str = result.to_string();
+
+        assert!(result_str.contains("fn byte_len (& self) -> usize"));
+        assert!(result_str.contains(
+            "self . a . byte_len () + self . vec . byte_len () + self . c . byte_len ()"
+        ));
+    }
+
+    #[test]
+    fn test_generate_byte_len_with_option() {
+        let name = format_ident!("TestStruct");
+
+        let field1: Field = parse_quote!(pub a: u8);
+        let field2: Field = parse_quote!(pub option: Option<u32>);
+
+        let meta_fields = vec![&field1];
+        let struct_fields = vec![&field2];
+
+        let result = generate_byte_len_impl(&name, &meta_fields, &struct_fields);
+        let result_str = result.to_string();
+
+        assert!(result_str.contains("fn byte_len (& self) -> usize"));
+        assert!(result_str.contains("self . a . byte_len () + self . option . byte_len ()"));
+    }
+
+    #[test]
+    fn test_generate_byte_len_with_bool() {
+        let name = format_ident!("TestStruct");
+
+        let field1: Field = parse_quote!(pub a: u8);
+        let field2: Field = parse_quote!(pub b: bool);
+
+        let meta_fields = vec![&field1, &field2];
+        let struct_fields: Vec<&Field> = vec![];
+
+        let result = generate_byte_len_impl(&name, &meta_fields, &struct_fields);
+        let result_str = result.to_string();
+
+        assert!(result_str.contains("fn byte_len (& self) -> usize"));
+        assert!(result_str.contains("self . a . byte_len () + core :: mem :: size_of :: < u8 > ()"));
+    }
+}