light-sdk-macros 0.23.0

Macros for Programs using the Light SDK for ZK Compression
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

//! Shared utility functions for compressible macro generation.

use syn::{
    punctuated::Punctuated, Data, DeriveInput, Field, Fields, GenericArgument, ItemStruct,
    PathArguments, Result, Token, Type,
};

/// Extracts named fields from an ItemStruct with proper error handling.
///
/// Returns an error if the struct doesn't have named fields.
pub(crate) fn extract_fields_from_item_struct(
    input: &ItemStruct,
) -> Result<&Punctuated<Field, Token![,]>> {
    match &input.fields {
        Fields::Named(fields) => Ok(&fields.named),
        _ => Err(syn::Error::new_spanned(
            input,
            "Only structs with named fields are supported",
        )),
    }
}

/// Extracts named fields from a DeriveInput with proper error handling.
///
/// Returns an error if the input is not a struct with named fields.
pub(crate) fn extract_fields_from_derive_input(
    input: &DeriveInput,
) -> Result<&Punctuated<Field, Token![,]>> {
    match &input.data {
        Data::Struct(data) => match &data.fields {
            Fields::Named(fields) => Ok(&fields.named),
            Fields::Unnamed(_) => Err(syn::Error::new_spanned(
                input,
                "Only structs with named fields are supported. Tuple structs cannot be light accounts.",
            )),
            Fields::Unit => Err(syn::Error::new_spanned(
                input,
                "Only structs with named fields are supported. Unit structs cannot be light accounts.",
            )),
        },
        Data::Enum(_) => Err(syn::Error::new_spanned(
            input,
            "Only structs are supported. Enums cannot be light accounts.",
        )),
        Data::Union(_) => Err(syn::Error::new_spanned(
            input,
            "Only structs are supported. Unions cannot be light accounts.",
        )),
    }
}

/// Determines if a type is a Copy type (primitives, Pubkey, and Options of Copy types).
///
/// This is used to decide whether to use `.clone()` or direct copy during field assignments.
#[inline(never)]
pub(crate) fn is_copy_type(ty: &Type) -> bool {
    match ty {
        Type::Path(type_path) => {
            if let Some(segment) = type_path.path.segments.last() {
                let type_name = segment.ident.to_string();
                matches!(
                    type_name.as_str(),
                    "u8" | "u16"
                        | "u32"
                        | "u64"
                        | "u128"
                        | "usize"
                        | "i8"
                        | "i16"
                        | "i32"
                        | "i64"
                        | "i128"
                        | "isize"
                        | "f32"
                        | "f64"
                        | "bool"
                        | "char"
                        | "Pubkey"
                ) || (type_name == "Option" && has_copy_inner_type(&segment.arguments))
            } else {
                false
            }
        }
        Type::Array(_) => true,
        _ => false,
    }
}

/// Checks if a type argument contains a Copy type (for generic types like Option<T>).
#[inline(never)]
pub(crate) fn has_copy_inner_type(args: &PathArguments) -> bool {
    match args {
        PathArguments::AngleBracketed(args) => args.args.iter().any(|arg| {
            if let GenericArgument::Type(ty) = arg {
                is_copy_type(ty)
            } else {
                false
            }
        }),
        _ => false,
    }
}

/// Determines if a type is specifically a Pubkey type.
#[inline(never)]
pub(crate) fn is_pubkey_type(ty: &Type) -> bool {
    if let Type::Path(type_path) = ty {
        if let Some(segment) = type_path.path.segments.last() {
            segment.ident == "Pubkey"
        } else {
            false
        }
    } else {
        false
    }
}