ezffi-macros 0.1.1

Proc-macros backing the ezffi crate
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

use quote::quote;
use syn::ItemEnum;

use crate::{Namer, structs::expand_type};

pub fn is_c_compatible_enum(item: &ItemEnum) -> bool {
    item.generics.gt_token.is_none()
        && item
            .variants
            .iter()
            .all(|v| matches!(v.fields, syn::Fields::Unit))
}

pub fn expand_enum(item: &ItemEnum) -> syn::Result<proc_macro2::TokenStream> {
    if item.generics.gt_token.is_some() {
        return Err(syn::Error::new_spanned(
            &item.generics,
            "generic enums are not supported by #[ezffi::export]",
        ));
    }

    if let Some(lt) = item.generics.lifetimes().next() {
        return Err(syn::Error::new_spanned(
            lt,
            "lifetime parameters are not supported by #[ezffi::export]",
        ));
    }

    // Enums no C-compatibles are wrapped in a struct behind *mut c_void, the same
    // way no C-compatible structs are exposed
    Ok(expand_type(&item.ident))
}

pub fn expand_c_enum(item: &ItemEnum) -> proc_macro2::TokenStream {
    let rust_ty_name = &item.ident;
    let c_ty_name = Namer::name_struct(rust_ty_name);
    let variants = &item.variants;
    let attrs = &item.attrs;

    let has_repr = attrs.iter().any(|a| a.path().is_ident("repr"));
    let repr = if has_repr {
        quote! {}
    } else {
        quote! { #[repr(C)] }
    };

    quote! {
        #[derive(Clone, Copy)]
        #repr
        #(#attrs)*
        pub enum #c_ty_name {
            #variants
        }

        pub type #rust_ty_name = #c_ty_name;

        impl ::ezffi::RustRefIntoC<()> for #c_ty_name {
            type C = #c_ty_name;

            unsafe fn ref_into_c(&self) -> Self::C { *self }
        }

        impl ::ezffi::RustOwnedIntoC<()> for #c_ty_name {
            type C = #c_ty_name;

            unsafe fn owned_into_c(self) -> Self::C { self }
        }

        impl ::ezffi::CRefIntoRust<#c_ty_name> for #c_ty_name {
            unsafe fn into_rust(&self) -> &#c_ty_name { self }
            unsafe fn into_rust_mut(&mut self) -> &mut #c_ty_name { self }
        }

        impl ::ezffi::COwnedIntoRust<#c_ty_name> for #c_ty_name {
            unsafe fn into_rust_owned(self) -> #c_ty_name { self }
        }
    }
}