interoptopus_proc_impl 0.16.0-alpha.20

Macros to produce Interoptopus item info.
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

#![doc = include_str!("../README.md")]
#![allow(clippy::needless_pass_by_value)]

extern crate proc_macro; // Apparently needed to be imported like this.

mod constant;
mod docs;
mod forbidden;
mod function;
mod runtime;
mod service;
mod skip;
mod types;

mod plugin;

use proc_macro2::TokenStream;
use quote::quote;
use syn::{Item, parse2};

#[must_use]
pub fn ffi(attr: TokenStream, item: TokenStream) -> TokenStream {
    // Helper function to handle results with consistent error formatting
    let handle_result = |result: syn::Result<TokenStream>| match result {
        Ok(tokens) => tokens,
        Err(err) => {
            let error = err.to_compile_error();
            quote! {
                #item
                #error
            }
        }
    };

    // Parse and forward to appropriate macro based on item type
    let result = parse2::<Item>(item.clone()).and_then(|parsed_item| match parsed_item {
        Item::Struct(_) | Item::Enum(_) => types::ffi(attr, item.clone()),
        Item::Fn(_) => function::ffi(attr, item.clone()),
        Item::Const(_) => constant::ffi(attr, item.clone()),
        Item::Impl(_) => service::ffi(attr, item.clone()),
        _ => Err(syn::Error::new_spanned(&parsed_item, "#[ffi] can only be applied to structs, enums, functions, const, or impl blocks")),
    });

    handle_result(result)
}

#[must_use]
pub fn derive_async_runtime(item: TokenStream) -> TokenStream {
    let handle_result = |result: syn::Result<TokenStream>| match result {
        Ok(tokens) => tokens,
        Err(err) => err.to_compile_error(),
    };

    handle_result(runtime::derive_async_runtime(item))
}

#[must_use]
pub fn plugin(input: TokenStream) -> TokenStream {
    plugin::plugin(input)
}