savvy-bindgen 0.8.4

Parse Rust functions, and generate C and R code
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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

use syn::{parse_quote, ItemEnum, ItemImpl};

use crate::extract_docs;

#[derive(Clone)]
pub struct SavvyEnum {
    /// Doc comments
    pub docs: Vec<String>,
    /// Attributes except for `#[savvy]`
    pub attrs: Vec<syn::Attribute>,
    /// Type name of the enum
    pub ty: syn::Ident,
    /// Variants
    pub variants: Vec<syn::Ident>,
}

impl SavvyEnum {
    pub fn new(orig: &syn::ItemEnum) -> syn::Result<Self> {
        let mut attrs = orig.attrs.clone();
        // Remove #[savvy]
        attrs.retain(|attr| attr != &parse_quote!(#[savvy]));
        // Extract doc comments
        let docs = extract_docs(attrs.as_slice());

        let ty = orig.ident.clone();

        let mut variants = Vec::new();

        for v in &orig.variants {
            if !matches!(v.fields, syn::Fields::Unit) {
                let e = syn::Error::new_spanned(
                    v.fields.clone(),
                    "savvy only supports a fieldless enum",
                );
                return Err(e);
            }

            if v.discriminant.is_some() {
                let e = syn::Error::new_spanned(
                    v.discriminant.clone().unwrap().1,
                    "savvy doesn't support an enum with discreminant",
                );
                return Err(e);
            }

            variants.push(v.ident.clone());
        }

        Ok(Self {
            docs,
            attrs,
            ty,
            variants,
        })
    }

    pub fn generate_enum_with_discriminant(&self) -> ItemEnum {
        let ty = &self.ty;
        let attrs = &self.attrs;

        let variants_tweaked = self
            .variants
            .iter()
            .enumerate()
            .map(|(i, v)| {
                let lit_i = syn::LitInt::new(&i.to_string(), v.span());
                parse_quote!(#v = #lit_i)
            })
            .collect::<Vec<syn::Variant>>();

        parse_quote!(
            #(#attrs)*
            pub enum #ty {
                #(#variants_tweaked),*
            }
        )
    }

    pub fn generate_try_from_impls(&self) -> Vec<ItemImpl> {
        let ty = &self.ty;

        let match_arms_ref = self
            .variants
            .iter()
            .enumerate()
            .map(|(i, v)| {
                let lit_i = syn::LitInt::new(&i.to_string(), v.span());
                parse_quote!(#lit_i => Ok(&#ty::#v))
            })
            .collect::<Vec<syn::Arm>>();

        let match_arms = self
            .variants
            .iter()
            .enumerate()
            .map(|(i, v)| {
                let lit_i = syn::LitInt::new(&i.to_string(), v.span());
                parse_quote!(#lit_i => Ok(#ty::#v))
            })
            .collect::<Vec<syn::Arm>>();

        vec![
            parse_quote!(
            impl TryFrom<#ty> for savvy::Sexp {
                type Error = savvy::Error;

                fn try_from(value: #ty) -> savvy::Result<Self> {
                    (value as i32).try_into()
                }
            }),
            parse_quote!(
                impl TryFrom<savvy::Sexp> for &#ty {
                    type Error = savvy::Error;

                    fn try_from(value: savvy::Sexp) -> savvy::Result<Self> {
                        let i = <i32>::try_from(value)?;
                        match i {
                            #(#match_arms_ref),*,
                            _ => Err(savvy::savvy_err!("Unexpected enum variant")),
                        }
                    }
                }
            ),
            parse_quote!(
                impl TryFrom<savvy::Sexp> for #ty {
                    type Error = savvy::Error;

                    fn try_from(value: savvy::Sexp) -> savvy::Result<Self> {
                        let i = <i32>::try_from(value)?;
                        match i {
                            #(#match_arms),*,
                            _ => Err(savvy::savvy_err!("Unexpected enum variant")),
                        }
                    }
                }
            ),
        ]
    }
}