ext-php-rs-derive 0.11.11

Derive macros for ext-php-rs.
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 proc_macro2::TokenStream;
use quote::quote;
use syn::{
    ForeignItemFn, ItemForeignMod, ReturnType, Signature, Token, punctuated::Punctuated,
    spanned::Spanned as _, token::Unsafe,
};

use crate::parsing::ident_to_php_name;
use crate::prelude::*;

pub fn parser(input: ItemForeignMod) -> Result<TokenStream> {
    input
        .items
        .into_iter()
        .map(|item| match item {
            syn::ForeignItem::Fn(func) => parse_function(func),
            _ => bail!(item => "Only `extern` functions are supported by PHP."),
        })
        .collect::<Result<Vec<_>>>()
        .map(|vec| quote! { #(#vec)* })
}

fn parse_function(mut func: ForeignItemFn) -> Result<TokenStream> {
    let ForeignItemFn {
        attrs, vis, sig, ..
    } = &mut func;
    sig.unsafety = Some(Unsafe::default()); // Function must be unsafe.

    let Signature { ident, .. } = &sig;

    let name = ident_to_php_name(ident);
    let params = sig
        .inputs
        .iter()
        .map(|input| match input {
            syn::FnArg::Typed(arg) => {
                let pat = &arg.pat;
                Some(quote! { &#pat })
            }
            syn::FnArg::Receiver(_) => None,
        })
        .collect::<Option<Punctuated<_, Token![,]>>>()
        .ok_or_else(|| {
            err!(sig.span() => "`self` parameters are not permitted inside `#[php_extern]` blocks.")
        })?;
    let ret = build_return(&name, &sig.output, &params);

    Ok(quote! {
        #(#attrs)* #vis #sig {
            use ::std::convert::TryInto;

            let callable = ::ext_php_rs::types::ZendCallable::try_from_name(
                #name
            ).expect(concat!("Unable to find callable function `", #name, "`."));

            #ret
        }
    })
}

fn build_return(
    name: &str,
    return_type: &ReturnType,
    params: &Punctuated<TokenStream, Token![,]>,
) -> TokenStream {
    match return_type {
        ReturnType::Default => quote! {
            callable.try_call(vec![ #params ]);
        },
        ReturnType::Type(_, _) => quote! {
            callable
                .try_call(vec![ #params ])
                .ok()
                .and_then(|zv| zv.try_into().ok())
                .expect(concat!("Failed to call function `", #name, "`."))
        },
    }
}