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)
}
}
}
}