mirascript-vm-derive 0.1.105

Derive macros for exposing live Rust values to MiraScript
Documentation
use std::collections::HashMap;

use proc_macro2::TokenStream;
use quote::{format_ident, quote};
use syn::{Error, Generics, Ident, Path, Result, Type, parse_quote};

use super::generic_visiter::type_uses_generic_parameter;

pub fn reject_duplicate_names<'a>(
    names: impl Iterator<Item = (&'a str, &'a proc_macro2::Span)>,
) -> Result<()> {
    let mut seen = HashMap::new();
    for (name, span) in names {
        if let Some(previous) = seen.insert(name, span) {
            let mut error = Error::new(*span, format!("duplicate Mira field name `{name}`"));
            error.combine(Error::new(*previous, "first exported with this name here"));
            return Err(error);
        }
    }
    Ok(())
}

pub fn add_read_bounds<'a>(
    generics: &'a mut Generics,
    types: impl IntoIterator<Item = &'a Type>,
    krate: &'a Path,
) {
    let types = types
        .into_iter()
        .filter(|ty| type_uses_generic_parameter(generics, ty))
        .collect::<Vec<_>>();
    for parameter in generics.type_params_mut() {
        parameter.bounds.push(parse_quote!('static));
    }
    let lifetimes = generics
        .lifetimes()
        .map(|parameter| parameter.lifetime.clone())
        .collect::<Vec<_>>();
    let where_clause = generics.make_where_clause();
    for lifetime in lifetimes {
        where_clause
            .predicates
            .push(parse_quote!(#lifetime: 'static));
    }
    for ty in types {
        where_clause
            .predicates
            .push(parse_quote!(#ty: #krate::__private::MiraField));
    }
}

pub fn create_getter(
    krate: &Path,
    index: usize,
    field: TokenStream,
    ty: &Type,
    from: Ident,
) -> TokenStream {
    quote! {
        #index => {
            let parent = unsafe { self_handle.upcast::<Self>() };
            ::core::result::Result::Ok(
                <#ty as #krate::__private::MiraField>::#from(
                    &self.#field,
                    parent,
                    #index,
                    |parent: &Self, index: usize| &parent.#field,
                )
            )
        },
    }
}

pub(crate) fn impl_common(
    ident: &Ident,
    generics: &Generics,
    krate: &Path,
    impl_type: &'static str,
) -> TokenStream {
    let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();

    let from_type = format_ident!("from_{impl_type}");
    let shaped_type_from_array = format_ident!("shaped_{impl_type}_from_array");
    let shaped_type_from_record = format_ident!("shaped_{impl_type}_from_record");

    let from_params = quote!(
        &self,
        parent: #krate::MiraHandle<P>,
        index: usize,
        getter: #krate::__private::MiraFieldGetter<P, Self>
    );
    let from_args = quote!(parent, index, getter);

    quote! {
        impl #impl_generics ::core::convert::From<#ident #ty_generics>
            for #krate::MiraManageable #where_clause
        {
            fn from(value: #ident #ty_generics) -> Self {
                #krate::MiraManageable::#from_type(value)
            }
        }

        impl #impl_generics #krate::__private::MiraField
            for #ident #ty_generics #where_clause
        {
            fn from_record<P: #krate::MiraRecord>(#from_params) -> #krate::MiraManageable {
                #krate::__private::#shaped_type_from_record(#from_args)
            }

            fn from_array<P: #krate::MiraArray>(#from_params) -> #krate::MiraManageable {
                #krate::__private::#shaped_type_from_array(#from_args)
            }
        }
    }
}