scheme_rs_macros/

lib.rs

use proc_macro::{self, TokenStream};
use proc_macro2::{Literal, Span};
use quote::{format_ident, quote};
use syn::{
    Attribute, DataEnum, DataStruct, DeriveInput, Error, Expr, ExprClosure, Fields, FnArg,
    GenericParam, Generics, Ident, ItemFn, LitBool, LitStr, Member, Meta, Pat, PatIdent, PatType,
    Result, Token, Type, TypePath, TypeReference, Visibility, braced, bracketed, parenthesized,
    parse::{Parse, ParseStream},
    parse_macro_input, parse_quote,
    punctuated::Punctuated,
    spanned::Spanned,
};

/// The `bridge` proc macro allows one to register Scheme procedures written in
/// Rust.
///
/// Rust functions registered with `bridge` must have the following form:
/// `async? fn(arg: &T, ... (rest_args: &[Value])?) -> Result<Vec<Value>, Exception>`
///
/// The types of the arguments can be any `T` for which `T: TryFrom<&Value>`, or
/// they can be a `&Value`. Scheme-rs will throw an excpetion if 
///
/// Bridge functions can be async if the `async` feature flag is enabled.
///
/// The `bridge` proc macro takes two arguments: `def` which specifies the
/// scheme procedure name and `lib` which specifies the library to register the
/// procedure to. At time of variable resolution, if the library has no scheme
/// code associated with it, all bridge functions registered to that library
/// will be assumed to be public. More control can be given by associating
/// scheme code with the library, in that case bridge functions will need to be
/// made public by putting them in the `export` spec.
#[proc_macro_attribute]
pub fn bridge(args: TokenStream, item: TokenStream) -> TokenStream {
    let mut name: Option<LitStr> = None;
    let mut lib: Option<LitStr> = None;
    let bridge_attr_parser = syn::meta::parser(|meta| {
        if meta.path.is_ident("name") {
            name = Some(meta.value()?.parse()?);
            Ok(())
        } else if meta.path.is_ident("lib") {
            lib = Some(meta.value()?.parse()?);
            Ok(())
        } else {
            Err(meta.error("unsupported bridge property"))
        }
    });

    parse_macro_input!(args with bridge_attr_parser);

    let name = name.unwrap().value();
    let lib = lib.unwrap().value();
    let bridge = parse_macro_input!(item as ItemFn);

    let impl_name = bridge.sig.ident.clone();
    let wrapper_name = impl_name.to_string();
    let wrapper_name = Ident::new(&wrapper_name, Span::call_site());

    let (rest_args, is_variadic) = if let Some(last_arg) = bridge.sig.inputs.last()
        && is_slice(&last_arg)
    {
        (quote!(rest_args), true)
    } else {
        (quote!(), false)
    };

    let num_args = if is_variadic {
        bridge.sig.inputs.len().saturating_sub(1)
    } else {
        bridge.sig.inputs.len()
    };

    let arg_names: Vec<_> = bridge
        .sig
        .inputs
        .iter()
        .enumerate()
        .map(|(i, arg)| {
            if let FnArg::Typed(PatType { pat, .. }) = arg {
                if let Pat::Ident(PatIdent { ident, .. }) = pat.as_ref() {
                    return ident.to_string();
                }
            }
            format!("arg{i}")
        })
        .collect();

    let arg_indices: Vec<_> = (0..num_args).collect();

    let visibility = bridge.vis.clone();

    if bridge.sig.asyncness.is_some() {
        quote! {
            #visibility fn #wrapper_name<'a>(
                runtime: &'a ::scheme_rs::runtime::Runtime,
                _env: &'a [::scheme_rs::value::Value],
                args: &'a [::scheme_rs::value::Value],
                rest_args: &'a [::scheme_rs::value::Value],
                dyn_state: &'a mut ::scheme_rs::proc::DynamicState,
                k: ::scheme_rs::value::Value,
            ) -> futures::future::BoxFuture<'a, scheme_rs::proc::Application> {
                #bridge

                Box::pin(
                    async move {
                        let result = #impl_name(
                            #(
                                match (&args[#arg_indices]).try_into() {
                                    Ok(ok) => ok,
                                    Err(err) => {
                                        return ::scheme_rs::exceptions::raise(
                                            runtime.clone(),
                                            err.into(),
                                            dyn_state,
                                        )
                                    }
                                },
                            )*
                            #rest_args
                        ).await;
                        // If the function returned an error, we want to raise
                        // it.
                        let result = match result {
                            Err(err) => return ::scheme_rs::exceptions::raise(
                                runtime.clone(),
                                err.into(),
                                dyn_state,
                            ),
                            Ok(result) => result,
                        };
                        let k = unsafe { k.try_into().unwrap_unchecked() };
                        ::scheme_rs::proc::Application::new(k, result)
                    }
                )
            }

            inventory::submit! {
                ::scheme_rs::registry::BridgeFn::new(
                    #name,
                    #lib,
                    #num_args,
                    #is_variadic,
                    ::scheme_rs::registry::Bridge::Async(#wrapper_name),
                    ::scheme_rs::registry::BridgeFnDebugInfo::new(
                        ::std::file!(),
                        ::std::line!(),
                        ::std::column!(),
                        0,
                        &[ #( #arg_names, )* ],
                    )
                )
            }
        }
    } else {
        quote! {
            #visibility fn #wrapper_name(
                runtime: &::scheme_rs::runtime::Runtime,
                _env: &[::scheme_rs::value::Value],
                args: &[::scheme_rs::value::Value],
                rest_args: &[::scheme_rs::value::Value],
                dyn_state: &mut ::scheme_rs::proc::DynamicState,
                k: ::scheme_rs::value::Value,
            ) -> scheme_rs::proc::Application {
                #bridge

                let result = #impl_name(
                    #(
                        match (&args[#arg_indices]).try_into() {
                            Ok(ok) => ok,
                            Err(err) => {
                                return ::scheme_rs::exceptions::raise(
                                    runtime.clone(),
                                    err.into(),
                                    dyn_state,
                                )
                            }
                        },
                    )*
                    #rest_args
                );

                // If the function returned an error, we want to raise
                // it.
                let result = match result {
                    Err(err) => return ::scheme_rs::exceptions::raise(
                        runtime.clone(),
                        err.into(),
                        dyn_state,
                    ),
                    Ok(result) => result,
                };

                let k = unsafe { k.try_into().unwrap_unchecked() };
                ::scheme_rs::proc::Application::new(k, result)
            }

            inventory::submit! {
                ::scheme_rs::registry::BridgeFn::new(
                    #name,
                    #lib,
                    #num_args,
                    #is_variadic,
                    ::scheme_rs::registry::Bridge::Sync(#wrapper_name),
                    ::scheme_rs::registry::BridgeFnDebugInfo::new(
                        ::std::file!(),
                        ::std::line!(),
                        ::std::column!(),
                        0,
                        &[ #( #arg_names, )* ],
                    )
                )
            }
        }
    }
    .into()
}

/// The `cps_bridge` proc macro allows one to register Scheme procedureds written
/// in Rust in a
/// [continuation-passing style](https://en.wikipedia.org/wiki/Continuation-passing_style).
///
/// The main benefit of this is to allow for Rust functions that call scheme
/// procedures in a tail-context. Essentially every scheme function, including
/// those that are not possible to express in base scheme, are expressible in
/// Rust because of this.
///
/// Functions registered with `cps_bridge` must take the following arguments:
///  - `runtime: &Runtime`: The runtime to which the procedure is registered.
///  - `env: &[Value]`: Environmental variables supplied to the procedure via
///    `Procedure::new`.
///  - `args: &[Value]`: The arguments to the procedure.
///  - `rest_args: &[Value]`: Any variadic arguments provided to the procedure.
///  - `dyn_state: &mut DynamicState`: The dynamic state of the program.
///  - `k: Value`: The current continuation.
///
/// The `cps_bridge` proc macro takes two arguments: `def` which specifies the
/// scheme procedure name and arguments and `lib` which specifies the library
/// to register the procedure to.
///
/// `cps_bridge` functions can be async if the `async` feature flag is enabled.
///
/// **Note:** `cps_bridge` functions _must_ be public to be registered to a
/// library! If a `cbs_bridge` function is declared as private, it does not take
/// a `def` or `lib` argument.
///
/// # Example: Scheme `apply` procedure written in Rust:
///
/// ```rust,ignore
/// #[cps_bridge(def = "apply arg1 . args", lib = "(rnrs base builtins (6))")]
/// pub fn apply(
///     _runtime: &Runtime,
///     _env: &[Value],
///     args: &[Value],
///     rest_args: &[Value],
///     _dyn_state: &mut DynamicState,
///     k: Value,
/// ) -> Result<Application, Exception> {
///     if rest_args.is_empty() {
///         return Err(Exception::wrong_num_of_args(2, args.len()));
///     }
///     let op: Procedure = args[0].clone().try_into()?;
///     let (last, args) = rest_args.split_last().unwrap();
///     let mut args = args.to_vec();
///     list_to_vec(last, &mut args);
///     args.push(k);
///     Ok(Application::new(op.clone(), args))
/// }
/// ```

#[proc_macro_attribute]
pub fn cps_bridge(args: TokenStream, item: TokenStream) -> TokenStream {
    let mut def: Option<LitStr> = None;
    let mut lib: Option<LitStr> = None;
    let bridge_attr_parser = syn::meta::parser(|meta| {
        if meta.path.is_ident("def") {
            def = Some(meta.value()?.parse()?);
            Ok(())
        } else if meta.path.is_ident("lib") {
            lib = Some(meta.value()?.parse()?);
            Ok(())
        } else {
            Err(meta.error("unsupported bridge property"))
        }
    });

    parse_macro_input!(args with bridge_attr_parser);

    let mut bridge = parse_macro_input!(item as ItemFn);
    let wrapper_name = Ident::new(&bridge.sig.ident.to_string(), Span::call_site());
    bridge.sig.ident = Ident::new("inner", Span::call_site());
    let impl_name = bridge.sig.ident.clone();

    let (vis, inventory) = if matches!(bridge.vis, Visibility::Public(_)) {
        let vis = std::mem::replace(&mut bridge.vis, Visibility::Inherited);
        let lib = lib.unwrap().value();
        let def = def.unwrap().value();
        let mut is_variadic = false;

        let mut def = def
            .split(" ")
            .filter_map(|x| {
                if x.is_empty() {
                    None
                } else if x == "." {
                    is_variadic = true;
                    None
                } else {
                    Some(x)
                }
            })
            .collect::<Vec<_>>();

        let name = def.remove(0);

        let num_args = def.len() - is_variadic as usize;

        let bridge_ptr = if bridge.sig.asyncness.is_some() {
            quote!(::scheme_rs::registry::Bridge::Async(#wrapper_name))
        } else {
            quote!(::scheme_rs::registry::Bridge::Sync(#wrapper_name))
        };

        let inventory = quote! {
            inventory::submit! {
                ::scheme_rs::registry::BridgeFn::new(
                    #name,
                    #lib,
                    #num_args,
                    #is_variadic,
                    #bridge_ptr,
                    ::scheme_rs::registry::BridgeFnDebugInfo::new(
                        ::std::file!(),
                        ::std::line!(),
                        ::std::column!(),
                        0,
                        &[ #( #def, )* ],
                    )
                )
            }
        };
        (vis, inventory)
    } else {
        if let Some(def) = def {
            return Error::new(
                def.span(),
                "name attribute is not supported for private functions",
            )
            .into_compile_error()
            .into();
        }
        if let Some(lib) = lib {
            return Error::new(
                lib.span(),
                "lib attribute is not supported for private functions",
            )
            .into_compile_error()
            .into();
        }
        let vis = std::mem::replace(&mut bridge.vis, Visibility::Inherited);
        (vis, quote!())
    };

    if bridge.sig.asyncness.is_some() {
        quote! {
            #vis fn #wrapper_name<'a>(
                runtime: &'a ::scheme_rs::runtime::Runtime,
                env: &'a [::scheme_rs::value::Value],
                args: &'a [::scheme_rs::value::Value],
                rest_args: &'a [::scheme_rs::value::Value],
                dyn_state: &'a mut ::scheme_rs::proc::DynamicState,
                k: ::scheme_rs::value::Value,
            ) -> futures::future::BoxFuture<'a, scheme_rs::proc::Application> {
                #bridge

                Box::pin(async move {
                    match #impl_name(
                        runtime,
                        env,
                        args,
                        rest_args,
                        dyn_state,
                        k
                    ).await {
                        Ok(app) => app,
                        Err(err) => ::scheme_rs::exceptions::raise(
                            runtime.clone(),
                            err.into(),
                            dyn_state
                        ),
                    }
                })
            }

            #inventory
        }
    } else {
        quote! {
            #vis fn #wrapper_name(
                runtime: &::scheme_rs::runtime::Runtime,
                env: &[::scheme_rs::value::Value],
                args: &[::scheme_rs::value::Value],
                rest_args: &[::scheme_rs::value::Value],
                dyn_state: &mut ::scheme_rs::proc::DynamicState,
                k: ::scheme_rs::value::Value,
            ) -> scheme_rs::proc::Application {
                #bridge

                match #impl_name(
                    runtime,
                    env,
                    args,
                    rest_args,
                    dyn_state,
                    k
                ) {
                    Ok(app) => app,
                    Err(err) => ::scheme_rs::exceptions::raise(
                        runtime.clone(),
                        err.into(),
                        dyn_state
                    )
                }
            }

            #inventory
        }
    }
    .into()
}

fn is_slice(arg: &FnArg) -> bool {
    matches!(arg, FnArg::Typed(PatType { ty, ..}) if matches!(ty.as_ref(), Type::Reference(TypeReference { elem, .. }) if matches!(elem.as_ref(), Type::Slice(_))))
}

/// Derive the `Trace` trait for a type.
///
/// `Trace` assumes that all fields of the type implement `Trace` or are a `Gc`
/// type. Occasionally you want to skip the tracing of a field, perhaps because
/// the type cannot implement `Trace`. The `#[trace(skip)]` attribute specifies
/// that the collector should ignore that field when tracing the type.
///
/// Skipping a field is always safe, but can cause memory leaks if the field
/// being skipped contains a `Gc`.
///
/// `Trace` will also automatically add `Trace` bounds to generic parameters.
/// To avoid this behavior, use the `#[trace(skip_bounds)]` attribute.
///
/// ```rust,ignore
/// #[derive(Trace)]
/// #[trace(skip_bounds)]
/// struct CustomType<T> {
///     #[trace(skip)]
///     inner: TypeYouDoNotOwn<T>
/// }
/// ```
#[proc_macro_derive(Trace, attributes(trace))]
pub fn derive_trace(input: TokenStream) -> TokenStream {
    let DeriveInput {
        attrs,
        ident,
        data,
        generics,
        ..
    } = parse_macro_input!(input);

    let tokens = match data {
        syn::Data::Struct(data_struct) => derive_trace_struct(&attrs, ident, data_struct, generics),
        syn::Data::Enum(data_enum) => derive_trace_enum(&attrs, ident, data_enum, generics),
        syn::Data::Union(union) => Err(Error::new(
            union.union_token.span(),
            "unions are not supported by Trace",
        )),
    };

    tokens.unwrap_or_else(syn::Error::into_compile_error).into()
}

fn derive_trace_struct(
    attrs: &[Attribute],
    name: Ident,
    record: DataStruct,
    generics: Generics,
) -> syn::Result<proc_macro2::TokenStream> {
    let fields = match record.fields {
        Fields::Named(fields) => fields.named,
        Fields::Unnamed(fields) => fields.unnamed,
        _ => {
            return Ok(quote! {
                unsafe impl ::scheme_rs::gc::Trace for #name {
                    unsafe fn visit_children(&self, visitor: &mut dyn FnMut(::scheme_rs::gc::OpaqueGcPtr)) {}

                    unsafe fn finalize(&mut self) {
                        unsafe {
                            ::std::ptr::drop_in_place(self as *mut Self)
                        }
                    }
                }
            });
        }
    };

    let Generics {
        mut params,
        where_clause,
        ..
    } = generics;

    let mut unbound_params = Punctuated::<GenericParam, Token![,]>::new();

    // TODO: Factor this out
    if !skip_bounds(attrs)? {
        for param in params.iter_mut() {
            match param {
                GenericParam::Type(ty) => {
                    ty.bounds.push(syn::TypeParamBound::Verbatim(
                        quote! { ::scheme_rs::gc::Trace },
                    ));
                    unbound_params.push(GenericParam::Type(syn::TypeParam::from(ty.ident.clone())));
                }
                param => unbound_params.push(param.clone()),
            }
        }
    }

    let (field_visits, field_drops): (Vec<_>, Vec<_>) = fields
        .iter()
        .enumerate()
        .map(|(i, f)| {
            let ident = f.ident.clone().map_or_else(
                || {
                    Member::Unnamed(syn::Index {
                        index: i as u32,
                        span: Span::call_site(),
                    })
                },
                Member::Named,
            );
            let ty = &f.ty;
            let is_gc = is_gc(ty);
            let skip_field = skip_field(&f.attrs)?;
            let visit = if skip_field {
                quote! {}
            } else if is_gc {
                quote! {
                    visitor(self.#ident.as_opaque());
                }
            } else {
                quote! {
                    <#ty as ::scheme_rs::gc::Trace>::visit_children(&self. #ident, visitor);
                }
            };
            let finalize = if skip_field {
                quote! {
                    core::ptr::drop_in_place(&mut self. #ident as *mut #ty);
                }
            } else if is_gc {
                quote! {}
            } else {
                quote! { <#ty as ::scheme_rs::gc::Trace>::finalize(&mut self. #ident); }
            };
            Ok((visit, finalize))
        })
        .collect::<syn::Result<Vec<_>>>()?
        .into_iter()
        .unzip();

    Ok(quote! {
        #[automatically_derived]
        unsafe impl<#params> ::scheme_rs::gc::Trace for #name <#unbound_params>
        #where_clause
        {
            unsafe fn visit_children(&self, visitor: &mut dyn FnMut(::scheme_rs::gc::OpaqueGcPtr)) {
                #(
                    #field_visits
                )*
            }

            unsafe fn finalize(&mut self) {
                #(
                    #field_drops
                )*
            }
        }
    })
}

fn derive_trace_enum(
    attrs: &[Attribute],
    name: Ident,
    data_enum: DataEnum,
    generics: Generics,
) -> syn::Result<proc_macro2::TokenStream> {
    let (visit_match_clauses, finalize_match_clauses): (Vec<_>, Vec<_>) = data_enum
        .variants
        .into_iter()
        .flat_map(|variant| {
            let fields: Vec<_> = match variant.fields {
                Fields::Named(ref named) => named
                    .named
                    .iter()
                    .map(|field| {
                        (
                            field.attrs.clone(),
                            field.ty.clone(),
                            field.ident.as_ref().unwrap().clone(),
                        )
                    })
                    .collect(),
                Fields::Unnamed(ref unnamed) => unnamed
                    .unnamed
                    .iter()
                    .enumerate()
                    .map(|(i, field)| {
                        let ident = Ident::new(&format!("t{i}"), Span::call_site());
                        (field.attrs.clone(), field.ty.clone(), ident)
                    })
                    .collect(),
                _ => return None,
            };
            Some((variant, fields))
        })
        .map(|(variant, fields)| {
            let visits = fields
                .iter()
                .map(|(attrs, ty, accessor)| {
                    let skip_field = skip_field(&attrs)?;

                    let visit = if skip_field {
                        quote! {
                            let _ = #accessor;
                        }
                    } else if is_gc(ty) {
                        quote! {
                            visitor(#accessor.as_opaque());
                        }
                    } else {
                        quote! {
                            <#ty as ::scheme_rs::gc::Trace>::visit_children(#accessor, visitor);
                        }
                    };
                    Ok(visit)
                })
                .collect::<syn::Result<Vec<_>>>()?;
            let drops: Vec<_> = fields
                .iter()
                .map(|(attrs, ty, accessor)| {
                    let skip_field = skip_field(&attrs).unwrap();

                    if skip_field {
                        quote! {
                            core::ptr::drop_in_place(#accessor as *mut #ty);
                        }
                    } else if is_gc(ty) {
                        quote! {}
                    } else {
                        quote! {
                            <#ty as ::scheme_rs::gc::Trace>::finalize(#accessor);
                        }
                    }
                })
                .collect();
            let field_name = fields.iter().map(|(_, _, field)| field);
            let fields_destructured = match variant.fields {
                Fields::Named(..) => quote! { { #( #field_name, )* .. } },
                _ => quote! { ( #( #field_name ),* ) },
            };
            let field_name = fields.iter().map(|(_, _, field)| field);
            let fields_destructured_mut = match variant.fields {
                Fields::Named(..) => quote! { { #( #field_name, )* .. } },
                _ => quote! { ( #( #field_name ),* ) },
            };
            let variant_name = variant.ident;
            Ok((
                quote! {
                    Self::#variant_name #fields_destructured => {
                        #(
                            #visits
                        )*
                    }
                },
                quote! {
                    Self::#variant_name #fields_destructured_mut => {
                        #(
                            #drops
                        )*
                    }
                },
            ))
        })
        .collect::<syn::Result<Vec<_>>>()?
        .into_iter()
        .unzip();

    let Generics {
        mut params,
        where_clause,
        ..
    } = generics;

    let mut unbound_params = Punctuated::<GenericParam, Token![,]>::new();

    if !skip_bounds(attrs)? {
        for param in params.iter_mut() {
            match param {
                GenericParam::Type(ty) => {
                    ty.bounds.push(syn::TypeParamBound::Verbatim(
                        quote! { ::scheme_rs::gc::Trace },
                    ));
                    unbound_params.push(GenericParam::Type(syn::TypeParam::from(ty.ident.clone())));
                }
                param => unbound_params.push(param.clone()),
            }
        }
    }

    Ok(quote! {
        #[automatically_derived]
        unsafe impl<#params> ::scheme_rs::gc::Trace for #name <#unbound_params>
        #where_clause
        {
            unsafe fn visit_children(&self, visitor: &mut dyn FnMut(::scheme_rs::gc::OpaqueGcPtr)) {
                match self {
                    #( #visit_match_clauses, )*
                    _ => (),
                }
            }

            unsafe fn finalize(&mut self) {
                match self {
                    #( #finalize_match_clauses, )*
                    _ => (),
                }
            }
        }
    })
}

fn skip_field(attrs: &[Attribute]) -> syn::Result<bool> {
    let mut skip_field = false;

    for attr in attrs.iter() {
        if attr.path().is_ident("trace") {
            let nested = attr.parse_args_with(Punctuated::<Meta, Token![,]>::parse_terminated)?;
            for meta in nested.into_iter() {
                if meta.path().is_ident("skip") {
                    skip_field = true;
                } else if meta.path().is_ident("skip_bounds") {
                    return Err(Error::new(
                        meta.path().span(),
                        "skip_bounds attribute is unsupported in this position",
                    ));
                } else {
                    return Err(Error::new(meta.path().span(), "unrecognized attribute"));
                }
            }
        }
    }

    Ok(skip_field)
}

fn skip_bounds(attrs: &[Attribute]) -> syn::Result<bool> {
    let mut skip_bounds = false;

    for attr in attrs.iter() {
        if attr.path().is_ident("trace") {
            let nested = attr.parse_args_with(Punctuated::<Meta, Token![,]>::parse_terminated)?;
            for meta in nested.into_iter() {
                if meta.path().is_ident("skip_bounds") {
                    skip_bounds = true;
                } else if meta.path().is_ident("skip") {
                    return Err(Error::new(
                        meta.path().span(),
                        "skip attribute is unsupported in this position",
                    ));
                } else {
                    return Err(Error::new(meta.path().span(), "unrecognized attribute"));
                }
            }
        }
    }

    Ok(skip_bounds)
}

fn is_gc(arg: &Type) -> bool {
    if let Type::Path(path) = arg {
        return path
            .path
            .segments
            .last()
            .map(|p| p.ident.to_string())
            .as_deref()
            == Some("Gc");
    }
    false
}

fn is_primitive(path: &TypePath, ty: &'static str) -> bool {
    path.path
        .segments
        .last()
        .map(|p| p.ident.to_string())
        .as_deref()
        == Some(ty)
}

fn rust_type_to_cranelift_type(ty: &Type) -> Option<Ident> {
    match ty {
        Type::Path(path) if is_primitive(path, "bool") => Some(format_ident!("I8")),
        Type::Path(path) if is_primitive(path, "i32") => Some(format_ident!("I32")),
        Type::Path(path) if is_primitive(path, "u32") => Some(format_ident!("I32")),
        Type::Path(_) => Some(format_ident!("I64")),
        Type::Ptr(_) => Some(format_ident!("I64")),
        Type::Tuple(_) => None,
        _ => unreachable!(),
    }
}

#[proc_macro_attribute]
pub fn runtime_fn(_args: TokenStream, item: TokenStream) -> TokenStream {
    let runtime_fn = parse_macro_input!(item as ItemFn);

    let name_ident = runtime_fn.sig.ident.clone();
    let name_lit = Literal::string(&runtime_fn.sig.ident.to_string());
    let ret = if let Some(ret_type) = match runtime_fn.sig.output {
        syn::ReturnType::Default => None,
        syn::ReturnType::Type(_, ref ty) => Some(rust_type_to_cranelift_type(&ty)),
    }
    .flatten()
    {
        quote! { sig.returns.push(AbiParam::new(types::#ret_type)); }
    } else {
        quote! {}
    };
    let args: Vec<_> = runtime_fn
        .sig
        .inputs
        .iter()
        .filter_map(|arg| {
            let FnArg::Typed(pat) = arg else {
                unreachable!();
            };
            rust_type_to_cranelift_type(&pat.ty)
        })
        .collect();

    quote! {
        #[allow(unused)]
        inventory::submit!(crate::runtime::RuntimeFn::new(
            |runtime_fns, module| {
                use cranelift::prelude::*;
                use cranelift_module::{Module, Linkage};
                let mut sig = module.make_signature();
                #(
                    sig.params.push(AbiParam::new(types::#args));
                )*
                #ret
                let func = module.declare_function(#name_lit, Linkage::Import, &sig).unwrap();
                runtime_fns.#name_ident(func);
            },
            |jit_builder| {
                jit_builder.symbol(#name_lit, #name_ident as *const u8);
            }
        ));


        #runtime_fn
    }
    .into()
}

enum RtdField {
    Immutable(LitStr),
    Mutable(LitStr),
}

impl Parse for RtdField {
    fn parse(input: ParseStream) -> Result<Self> {
        if input.peek(LitStr) {
            Ok(Self::Immutable(input.parse()?))
        } else {
            let mutability: Ident = input.parse()?;
            let constructor = if mutability == "immutable" {
                RtdField::Immutable
            } else if mutability == "mutable" {
                RtdField::Mutable
            } else {
                return Err(Error::new(
                    mutability.span(),
                    format!("invalid mutability '{mutability}'"),
                ));
            };
            let content;
            parenthesized!(content in input);
            let name: LitStr = content.parse()?;
            Ok((constructor)(name))
        }
    }
}

impl RtdField {
    fn into_token_stream(self) -> proc_macro2::TokenStream {
        match self {
            Self::Immutable(name) => quote! {
                ::scheme_rs::records::Field::Immutable(::scheme_rs::symbols::Symbol::intern(#name))
            },
            Self::Mutable(name) => quote! {
                ::scheme_rs::records::Field::Mutable(::scheme_rs::symbols::Symbol::intern(#name))
            },
        }
    }
}

struct Rtd {
    name: LitStr,
    parent: Option<Expr>,
    opaque: Option<Expr>,
    sealed: Option<LitBool>,
    uid: Option<LitStr>,
    constructor: Option<ExprClosure>,
    fields: Option<Vec<RtdField>>,
    lib: Option<LitStr>,
}

impl Parse for Rtd {
    fn parse(input: ParseStream) -> Result<Self> {
        let mut name = None;
        let mut parent = None;
        let mut opaque = None;
        let mut sealed = None;
        let mut fields = None;
        let mut uid = None;
        let mut lib = None;
        let mut constructor: Option<ExprClosure> = None;
        while !input.is_empty() {
            let keyword: Ident = input.parse()?;
            if keyword == "name" {
                if name.is_some() {
                    return Err(Error::new(keyword.span(), "duplicate definition of name"));
                }
                let _: Token![:] = input.parse()?;
                name = Some(input.parse()?);
            } else if keyword == "parent" {
                if parent.is_some() {
                    return Err(Error::new(keyword.span(), "duplicate definition of parent"));
                }
                let _: Token![:] = input.parse()?;
                parent = Some(input.parse()?);
            } else if keyword == "constructor" {
                if constructor.is_some() {
                    return Err(Error::new(
                        keyword.span(),
                        "duplicate definition of constructor",
                    ));
                }
                let _: Token![:] = input.parse()?;
                constructor = Some(input.parse()?);
            } else if keyword == "opaque" {
                if opaque.is_some() {
                    return Err(Error::new(keyword.span(), "duplicate definition of opaque"));
                }
                let _: Token![:] = input.parse()?;
                opaque = Some(input.parse()?);
            } else if keyword == "sealed" {
                if sealed.is_some() {
                    return Err(Error::new(keyword.span(), "duplicate definition of sealed"));
                }
                let _: Token![:] = input.parse()?;
                sealed = Some(input.parse()?);
            } else if keyword == "uid" {
                if uid.is_some() {
                    return Err(Error::new(keyword.span(), "duplicate definition of uid"));
                }
                let _: Token![:] = input.parse()?;
                uid = Some(input.parse()?);
            } else if keyword == "lib" {
                if lib.is_some() {
                    return Err(Error::new(keyword.span(), "duplicate definition of lib"));
                }
                let _: Token![:] = input.parse()?;
                lib = Some(input.parse()?);
            } else if keyword == "fields" {
                if fields.is_some() {
                    return Err(Error::new(keyword.span(), "duplicate definition of fields"));
                }
                let _: Token![:] = input.parse()?;
                let content;
                bracketed!(content in input);
                let punctuated_fields = content.parse_terminated(RtdField::parse, Token![,])?;
                fields = Some(punctuated_fields.into_iter().collect());
            } else {
                return Err(Error::new(keyword.span(), "unknown field name"));
            }

            if !input.is_empty() {
                let _: Token![,] = input.parse()?;
            }
        }

        let Some(name) = name else {
            return Err(Error::new(input.span(), "name field is required"));
        };

        if !sealed.as_ref().map_or(false, LitBool::value) && constructor.is_none() {
            return Err(Error::new(
                input.span(),
                "unsealed records must have a constructor defined",
            ));
        }

        Ok(Rtd {
            name,
            parent,
            opaque,
            sealed,
            uid,
            constructor,
            fields,
            lib,
        })
    }
}

/// Convenience macro for declaring RecordTypeDescriptors
#[proc_macro]
pub fn rtd(tokens: TokenStream) -> TokenStream {
    let Rtd {
        name,
        parent,
        opaque,
        sealed,
        uid,
        constructor,
        fields,
        lib,
    } = parse_macro_input!(tokens as Rtd);

    let fields = fields
        .into_iter()
        .flatten()
        .map(RtdField::into_token_stream)
        .collect::<Vec<_>>();
    let inherits = match parent {
        Some(parent) => quote!({
            let parent = <#parent as ::scheme_rs::records::SchemeCompatible>::rtd();
            let mut inherits = parent.inherits.clone();
            inherits.insert(::by_address::ByAddress(parent));
            inherits
        }),
        None => quote!(Default::default()),
    };
    let rust_parent_constructor = match constructor {
        Some(constructor) => {
            let num_inputs = constructor.inputs.len();
            let inputs = 0..num_inputs;
            let types = inputs.clone().map(|_| quote!(::scheme_rs::value::Value));
            quote!(Some({
                ::scheme_rs::records::RustParentConstructor::new(|vals| {
                    if vals.len() != #num_inputs {
                        return Err(::scheme_rs::exceptions::Exception::wrong_num_of_args(#num_inputs, vals.len()));
                    }
                    let constructor: fn(#(#types,)*) -> Result<_, ::scheme_rs::exceptions::Exception> = #constructor;
                    Ok(::scheme_rs::records::into_scheme_compatible(::scheme_rs::gc::Gc::new((constructor)(#(vals[#inputs].clone(),)*)?)))
                })
            }))
        }
        None => quote!(None),
    };
    let opaque = opaque.unwrap_or_else(|| parse_quote!(false));
    let sealed = sealed.unwrap_or_else(|| parse_quote!(false));
    let uid = match uid {
        Some(uid) => quote!(Some(::scheme_rs::symbols::Symbol::intern(#uid))),
        None => quote!(None),
    };

    let bridge = lib.map(|lib| {
        let name = format!("{}-rtd", name.value());
        quote! {
            #[::scheme_rs_macros::bridge(name = #name, lib = #lib)]
            pub fn rtd() -> Result<Vec<::scheme_rs::value::Value>, ::scheme_rs::exceptions::Exception> {
                Ok(vec![::scheme_rs::value::Value::from(RTD.clone())])
            }
        }
    });

    quote! {
        {
            static RTD: std::sync::LazyLock<std::sync::Arc<::scheme_rs::records::RecordTypeDescriptor>> =
                std::sync::LazyLock::new(|| {
                    std::sync::Arc::new(::scheme_rs::records::RecordTypeDescriptor {
                        name: ::scheme_rs::symbols::Symbol::intern(#name),
                        inherits: #inherits,
                        opaque: #opaque,
                        sealed: #sealed,
                        uid: #uid,
                        field_index_offset: 0,
                        fields: vec![ #( #fields, )* ],
                        rust_parent_constructor: #rust_parent_constructor,
                        rust_type: true
                    })
                });
            #bridge
            RTD.clone()
        }
    }.into()
}

struct DctField {
    name: Ident,
    ty: Type,
}

impl Parse for DctField {
    fn parse(input: ParseStream) -> Result<Self> {
        let name: Ident = input.parse()?;
        let _: Token![:] = input.parse()?;
        let ty: Type = input.parse()?;
        Ok(Self { name, ty })
    }
}

struct DefineConditionType {
    scheme_name: LitStr,
    rust_name: Ident,
    lib: Option<LitStr>,
    parent: Type,
    constructor: Option<ExprClosure>,
    fields: Option<Vec<DctField>>,
    dbg: Option<ExprClosure>,
}

impl Parse for DefineConditionType {
    fn parse(input: ParseStream) -> Result<Self> {
        let mut scheme_name = None;
        let mut rust_name = None;
        let mut parent = None;
        let mut constructor = None;
        let mut fields = None;
        let mut dbg = None;
        let mut lib = None;

        while !input.is_empty() {
            let keyword: Ident = input.parse()?;
            if keyword == "scheme_name" {
                if scheme_name.is_some() {
                    return Err(Error::new(
                        keyword.span(),
                        "duplicate definition of scheme_name",
                    ));
                }
                let _: Token![:] = input.parse()?;
                scheme_name = Some(input.parse()?);
            } else if keyword == "lib" {
                if lib.is_some() {
                    return Err(Error::new(
                        keyword.span(),
                        "duplicate definition of lib",
                    ));
                }
                let _: Token![:] = input.parse()?;
                lib = Some(input.parse()?);
            } else if keyword == "rust_name" {
                if rust_name.is_some() {
                    return Err(Error::new(
                        keyword.span(),
                        "duplicate definition of rust_name",
                    ));
                }
                let _: Token![:] = input.parse()?;
                rust_name = Some(input.parse()?);
            } else if keyword == "parent" {
                if parent.is_some() {
                    return Err(Error::new(keyword.span(), "duplicate definition of parent"));
                }
                let _: Token![:] = input.parse()?;
                parent = Some(input.parse()?);
            } else if keyword == "constructor" {
                if constructor.is_some() {
                    return Err(Error::new(
                        keyword.span(),
                        "duplicate definition of constructor",
                    ));
                }
                let _: Token![:] = input.parse()?;
                constructor = Some(input.parse()?);
            } else if keyword == "debug" {
                if dbg.is_some() {
                    return Err(Error::new(keyword.span(), "duplicate definition of debug"));
                }
                let _: Token![:] = input.parse()?;
                dbg = Some(input.parse()?);
            } else if keyword == "fields" {
                if fields.is_some() {
                    return Err(Error::new(keyword.span(), "duplicate definition of fields"));
                }
                let _: Token![:] = input.parse()?;
                let content;
                braced!(content in input);
                let punctuated_fields = content.parse_terminated(DctField::parse, Token![,])?;
                fields = Some(punctuated_fields.into_iter().collect());
            } else {
                return Err(Error::new(keyword.span(), "unknown field name"));
            }

            if !input.is_empty() {
                let _: Token![,] = input.parse()?;
            }
        }

        let Some(scheme_name) = scheme_name else {
            return Err(Error::new(input.span(), "scheme_name field is required"));
        };

        let Some(rust_name) = rust_name else {
            return Err(Error::new(input.span(), "rust_name field is required"));
        };

        let Some(parent) = parent else {
            return Err(Error::new(input.span(), "parent field is required"));
        };

        Ok(DefineConditionType {
            scheme_name,
            rust_name,
            parent,
            constructor,
            fields,
            dbg,
            lib,
        })
    }
}

#[proc_macro]
pub fn define_condition_type(tokens: TokenStream) -> TokenStream {
    let DefineConditionType {
        scheme_name,
        rust_name,
        parent,
        constructor,
        fields,
        dbg,
        lib,
    } = parse_macro_input!(tokens as DefineConditionType);

    let (field_names, field_tys): (Vec<_>, Vec<_>) = fields
        .into_iter()
        .flatten()
        .map(|field| (field.name, field.ty))
        .unzip();

    let field_name_strs = field_names
        .clone()
        .into_iter()
        .map(|field_name| LitStr::new(&field_name.to_string(), field_name.span()));

    let field_idxs = 0..field_names.len();

    let lib = lib.map(|lib| quote!(lib: #lib,));

    let constructor =  constructor.map_or_else(
        || quote! {
            constructor: || Ok(#rust_name::default()),
        },
        |constructor| {
            quote!(
                constructor: #constructor,
            )
        });

    let dbg = dbg.map(|dbg| {
        quote!(
            let dbg: fn(&Self, &mut std::fmt::Formatter<'_>) -> std::fmt::Result = #dbg;
            (dbg)(self, f)?;
        )
    });

    quote! {
        #[derive(Clone, ::scheme_rs::gc::Trace)]
        pub struct #rust_name {
            pub parent: ::scheme_rs::gc::Gc<#parent>,
            #( pub #field_names: #field_tys, )*

        }

        impl ::scheme_rs::records::SchemeCompatible for #rust_name {
            fn rtd() -> std::sync::Arc<::scheme_rs::records::RecordTypeDescriptor> {
                ::scheme_rs::records::rtd!(
                    name: #scheme_name,
                    parent: #parent,
                    #lib
                    fields: [#(#field_name_strs,)*],
                    #constructor
                )
            }

            fn extract_embedded_record(
                &self,
                rtd: &std::sync::Arc<::scheme_rs::records::RecordTypeDescriptor>
            ) -> Option<::scheme_rs::gc::Gc<dyn ::scheme_rs::records::SchemeCompatible>> {
                #parent::rtd()
                    .is_subtype_of(rtd)
                    .then(|| ::scheme_rs::records::into_scheme_compatible(self.parent.clone()))
            }

            fn get_field(&self, k: usize) -> Result<::scheme_rs::value::Value, ::scheme_rs::exceptions::Exception> {
                match k {
                    #(#field_idxs => Ok(::scheme_rs::value::Value::from(self.#field_names.clone())),)*
                    _ => Err(Exception::error(format!("invalid record field: {k}"))),
                }
            }
        }

        impl std::fmt::Debug for #rust_name {
            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                #dbg
                Ok(())
            }
        }
    }
    .into()
}

// Internal use only:

#[proc_macro_attribute]
pub fn maybe_async(_args: TokenStream, item: TokenStream) -> TokenStream {
    let func = parse_macro_input!(item as ItemFn);
    let mut async_func = func.clone();
    async_func.sig.asyncness = Some(Token![async](Span::call_site()));
    quote! {
        #[cfg(not(feature = "async"))]
        #func

        #[cfg(feature = "async")]
        #async_func
    }
    .into()
}

#[proc_macro]
pub fn maybe_await(tokens: TokenStream) -> TokenStream {
    let tokens = proc_macro2::TokenStream::from(tokens);
    quote! {
        {
            #[cfg(not(feature = "async"))]
            let result = #tokens ;

            #[cfg(feature = "async")]
            let result = #tokens .await;

            result
        }
    }
    .into()
}