mirascript-vm-derive 0.1.105

Derive macros for exposing live Rust values to MiraScript
Documentation
use proc_macro2::TokenStream;
use quote::{ToTokens, format_ident, quote};
use syn::{
    Error, FnArg, ItemFn, LitStr, Path, PathArguments, Result, ReturnType, Type, spanned::Spanned,
};

use super::{Context, Expanded, Export, Options, utils::*};

pub fn expand(item: ItemFn, options: Options, parent: Option<&Context>) -> Result<Expanded> {
    validate_function(&item)?;
    let ident = &item.sig.ident;
    let rust_name = rust_name(ident);
    let full_name = options
        .rename
        .as_ref()
        .map(LitStr::value)
        .unwrap_or_else(|| {
            parent
                .map(|parent| format!("{}.{}", parent.full_name, rust_name))
                .unwrap_or_else(|| rust_name.clone())
        });
    let export_name = options
        .use_name
        .as_ref()
        .map(LitStr::value)
        .unwrap_or_else(|| rust_name.clone());
    let const_ident = options
        .const_name
        .clone()
        .unwrap_or_else(|| upper_ident(ident));
    let krate = options.crate_path(parent);
    let hidden = format_ident!("__MiraFunction_{rust_name}", span = ident.span());
    let vis = &item.vis;
    let cfg = conditional_attrs(&item.attrs);
    let call = function_call(&item, &krate)?;
    let name = LitStr::new(&full_name, ident.span());

    let tokens = quote! {
        #item

        #(#cfg)*
        #[doc(hidden)]
        #[allow(non_camel_case_types)]
        #vis struct #hidden;

        #(#cfg)*
        impl #krate::MiraFunction for #hidden {
            fn call(
                &self,
                runtime: &mut #krate::Runtime,
                args: &[#krate::MiraValue],
            ) -> #krate::Result<#krate::MiraManageable> {
                #call
            }

            fn name(&self) -> &str {
                #name
            }
        }

        #(#cfg)*
        impl ::core::convert::From<#hidden> for #krate::MiraManageable {
            fn from(value: #hidden) -> Self {
                #krate::MiraManageable::from_function(value)
            }
        }

        #(#cfg)*
        #[doc = concat!("MiraScript function value for [`", stringify!(#ident), "`].")]
        #[allow(non_upper_case_globals)]
        #vis const #const_ident: #hidden = #hidden;
    };

    Ok(Expanded {
        tokens,
        export: parent.map(|_| Export {
            key: export_name,
            accessor: quote!(#const_ident),
            span: ident.span(),
        }),
    })
}

fn validate_function(item: &ItemFn) -> Result<()> {
    let signature = &item.sig;
    if signature.constness.is_some() {
        return Err(Error::new_spanned(
            signature.constness,
            "Mira functions cannot be `const`",
        ));
    }
    if signature.asyncness.is_some() {
        return Err(Error::new_spanned(
            signature.asyncness,
            "Mira functions cannot be `async`",
        ));
    }
    if !matches!(
        signature.safety,
        syn::Safety::Default | syn::Safety::Safe(_)
    ) {
        return Err(Error::new_spanned(
            &signature.safety,
            "Mira functions cannot be `unsafe`",
        ));
    }
    if signature.abi.is_some() {
        return Err(Error::new_spanned(
            &signature.abi,
            "Mira functions cannot use an explicit ABI",
        ));
    }
    if !signature.generics.params.is_empty() || signature.generics.where_clause.is_some() {
        return Err(Error::new_spanned(
            &signature.generics,
            "Mira functions cannot be generic",
        ));
    }
    if signature.variadic.is_some() {
        return Err(Error::new_spanned(
            &signature.variadic,
            "use a final `&[MiraValue]` parameter for remaining arguments",
        ));
    }
    if signature.receiver().is_some() {
        return Err(Error::new_spanned(
            signature.receiver(),
            "Mira functions must be free functions",
        ));
    }
    Ok(())
}

fn function_call(item: &ItemFn, krate: &Path) -> Result<TokenStream> {
    let mut runtime = false;
    let mut rest = false;
    let mut fixed = Vec::new();

    for (position, argument) in item.sig.inputs.iter().enumerate() {
        let FnArg::Typed(argument) = argument else {
            return Err(Error::new_spanned(
                argument,
                "Mira functions cannot have a receiver",
            ));
        };
        if is_runtime(&argument.ty) {
            if position != 0 {
                return Err(Error::new_spanned(
                    argument,
                    "`&mut Runtime` must be the first parameter",
                ));
            }
            runtime = true;
            continue;
        }
        if is_rest(&argument.ty) {
            if position + 1 != item.sig.inputs.len() {
                return Err(Error::new_spanned(
                    argument,
                    "`&[MiraValue]` must be the final parameter",
                ));
            }
            rest = true;
            continue;
        }
        fixed.push(argument);
    }

    let conversions = fixed.iter().enumerate().map(|(index, argument)| {
        let variable = format_ident!("__mira_arg_{index}");
        let ty = &argument.ty;
        let optional = is_optional(ty);
        let argument_name = LitStr::new(
            &argument.pat.to_token_stream().to_string(),
            argument.pat.span(),
        );
        if optional {
            quote! {
                let #variable: #ty = #krate::__private::native_argument_optional(
                    runtime,
                    args.get(#index).copied(),
                )?;
            }
        } else {
            quote! {
                let #variable: #ty = #krate::__private::native_argument(
                    runtime,
                    *args.get(#index).ok_or_else(|| #krate::MiraError::runtime(
                        #krate::RuntimeErrorKind::MissingArgument { name: #argument_name },
                    ))?,
                )?;
            }
        }
    });
    let fixed_variables = (0..fixed.len()).map(|index| format_ident!("__mira_arg_{index}"));
    let mut arguments = Vec::new();
    if runtime {
        arguments.push(quote!(runtime));
    }
    arguments.extend(fixed_variables.map(|variable| quote!(#variable)));
    if rest {
        let fixed_len = fixed.len();
        arguments.push(quote!(if args.len() > #fixed_len { &args[#fixed_len..] } else { &[] }));
    }
    let ident = &item.sig.ident;
    let invocation = quote!(#ident(#(#arguments),*));
    let result = if returns_result(&item.sig.output) {
        quote!(#krate::__private::native_result(#invocation))
    } else {
        quote!(::core::result::Result::Ok(
            ::core::convert::Into::<#krate::MiraManageable>::into(#invocation),
        ))
    };

    Ok(quote! {
        #(#conversions)*
        #result
    })
}

fn is_runtime(ty: &Type) -> bool {
    let Type::Reference(reference) = ty else {
        return false;
    };
    reference.mutability.is_some() && is_path_name(&reference.elem, "Runtime")
}

fn is_rest(ty: &Type) -> bool {
    let Type::Reference(reference) = ty else {
        return false;
    };
    if reference.mutability.is_some() {
        return false;
    }
    let Type::Slice(slice) = reference.elem.as_ref() else {
        return false;
    };
    is_path_name(&slice.elem, "MiraValue")
}

fn is_optional(ty: &Type) -> bool {
    let Type::Path(path) = ty else {
        return false;
    };
    path.qself.is_none()
        && path.path.segments.last().is_some_and(|segment| {
            segment.ident == "Option"
                && matches!(segment.arguments, PathArguments::AngleBracketed(_))
        })
}

fn is_path_name(ty: &Type, name: &str) -> bool {
    let Type::Path(path) = ty else {
        return false;
    };
    path.qself.is_none()
        && path
            .path
            .segments
            .last()
            .is_some_and(|segment| segment.ident == name && segment.arguments.is_empty())
}

fn returns_result(output: &ReturnType) -> bool {
    let ReturnType::Type(_, ty) = output else {
        return false;
    };
    let Type::Path(path) = ty.as_ref() else {
        return false;
    };
    path.qself.is_none()
        && path.path.segments.last().is_some_and(|segment| {
            segment.ident == "Result"
                && matches!(segment.arguments, PathArguments::AngleBracketed(_))
        })
}