//! Implementation of an [`Into`] derive macro. use std::{borrow::Cow, iter}; use proc_macro2::{Span, TokenStream}; use quote::{quote, ToTokens as _}; use syn::{ ext::IdentExt as _, parse::{discouraged::Speculative as _, Parse, ParseStream}, punctuated::Punctuated, spanned::Spanned as _, token, Ident, }; use crate::{ parsing::Type, utils::{polyfill, Either, FieldsExt as _}, }; /// Expands an [`Into`] derive macro. pub fn expand(input: &syn::DeriveInput, _: &'static str) -> syn::Result { let data = match &input.data { syn::Data::Struct(data) => Ok(data), syn::Data::Enum(e) => Err(syn::Error::new( e.enum_token.span(), "`Into` cannot be derived for enums", )), syn::Data::Union(u) => Err(syn::Error::new( u.union_token.span(), "`Into` cannot be derived for unions", )), }?; let attr = StructAttribute::parse_attrs(&input.attrs, &data.fields)? .unwrap_or_else(|| StructAttribute { owned: Some(Punctuated::new()), r#ref: None, ref_mut: None, }); let ident = &input.ident; let fields = data .fields .iter() .enumerate() .filter_map(|(i, f)| match SkipFieldAttribute::parse_attrs(&f.attrs) { Ok(None) => Some(Ok(( &f.ty, f.ident .as_ref() .map_or_else(|| Either::Right(syn::Index::from(i)), Either::Left), ))), Ok(Some(_)) => None, Err(e) => Some(Err(e)), }) .collect::>>()?; let (fields_tys, fields_idents): (Vec<_>, Vec<_>) = fields.into_iter().unzip(); let (fields_tys, fields_idents) = (&fields_tys, &fields_idents); let expand = |tys: Option>, r: bool, m: bool| { let Some(tys) = tys else { return Either::Left(iter::empty()); }; let lf = r.then(|| syn::Lifetime::new("'__derive_more_into", Span::call_site())); let r = r.then(token::And::default); let m = m.then(token::Mut::default); let gens = if let Some(lf) = lf.clone() { let mut gens = input.generics.clone(); gens.params.push(syn::LifetimeParam::new(lf).into()); Cow::Owned(gens) } else { Cow::Borrowed(&input.generics) }; Either::Right( if tys.is_empty() { Either::Left(iter::once(Type::tuple(fields_tys.clone()))) } else { Either::Right(tys.into_iter()) } .map(move |ty| { let tys = fields_tys.validate_type(&ty)?.collect::>(); let (impl_gens, _, where_clause) = gens.split_for_impl(); let (_, ty_gens, _) = input.generics.split_for_impl(); Ok(quote! { #[automatically_derived] impl #impl_gens ::core::convert::From<#r #lf #m #ident #ty_gens> for ( #( #r #lf #m #tys ),* ) #where_clause { #[inline] fn from(value: #r #lf #m #ident #ty_gens) -> Self { (#( <#r #m #tys as ::core::convert::From<_>>::from( #r #m value. #fields_idents ) ),*) } } }) }), ) }; [ expand(attr.owned, false, false), expand(attr.r#ref, true, false), expand(attr.ref_mut, true, true), ] .into_iter() .flatten() .collect() } /// Representation of an [`Into`] derive macro struct container attribute. /// /// ```rust,ignore /// #[into()] /// #[into(owned(), ref(), ref_mut())] /// ``` #[derive(Debug, Default)] struct StructAttribute { /// [`Type`]s wrapped into `owned(...)` or simply `#[into(...)]`. owned: Option>, /// [`Type`]s wrapped into `ref(...)`. r#ref: Option>, /// [`Type`]s wrapped into `ref_mut(...)`. ref_mut: Option>, } impl StructAttribute { /// Parses a [`StructAttribute`] from the provided [`syn::Attribute`]s. fn parse_attrs( attrs: impl AsRef<[syn::Attribute]>, fields: &syn::Fields, ) -> syn::Result> { fn infer(v: T) -> T where T: for<'a> FnOnce(ParseStream<'a>) -> syn::Result, { v } attrs .as_ref() .iter() .filter(|attr| attr.path().is_ident("into")) .try_fold(None, |mut attrs, attr| { let merge = |out: &mut Option<_>, tys| match (out.as_mut(), tys) { (None, Some(tys)) => { *out = Some::>(tys); } (Some(out), Some(tys)) => out.extend(tys), (Some(_), None) | (None, None) => {} }; let field_attr = attr.parse_args_with(infer(|stream| Self::parse(stream, fields)))?; let out = attrs.get_or_insert_with(Self::default); merge(&mut out.owned, field_attr.owned); merge(&mut out.r#ref, field_attr.r#ref); merge(&mut out.ref_mut, field_attr.ref_mut); Ok(attrs) }) } /// Parses a single [`StructAttribute`]. fn parse(content: ParseStream<'_>, fields: &syn::Fields) -> syn::Result { check_legacy_syntax(content, fields)?; let mut out = Self::default(); let parse_inner = |ahead, types: &mut Option<_>| { content.advance_to(&ahead); let types = types.get_or_insert_with(Punctuated::new); if content.peek(token::Paren) { let inner; syn::parenthesized!(inner in content); types.extend( inner .parse_terminated(Type::parse, token::Comma)? .into_pairs(), ); } if content.peek(token::Comma) { let comma = content.parse::()?; if !types.empty_or_trailing() { types.push_punct(comma); } } Ok(()) }; let mut has_wrapped_type = false; let mut top_level_type = None; while !content.is_empty() { let ahead = content.fork(); let res = if ahead.peek(Ident::peek_any) { ahead.call(Ident::parse_any).map(Into::into) } else { ahead.parse::() }; match res { Ok(p) if p.is_ident("owned") => { has_wrapped_type = true; parse_inner(ahead, &mut out.owned)?; } Ok(p) if p.is_ident("ref") => { has_wrapped_type = true; parse_inner(ahead, &mut out.r#ref)?; } Ok(p) if p.is_ident("ref_mut") => { has_wrapped_type = true; parse_inner(ahead, &mut out.ref_mut)?; } _ => { let ty = content.parse::()?; let _ = top_level_type.get_or_insert_with(|| ty.clone()); out.owned.get_or_insert_with(Punctuated::new).push_value(ty); if content.peek(token::Comma) { out.owned .get_or_insert_with(Punctuated::new) .push_punct(content.parse::()?) } } } } if let Some(ty) = top_level_type.filter(|_| has_wrapped_type) { Err(syn::Error::new( ty.span(), format!( "mixing regular types with wrapped into \ `owned`/`ref`/`ref_mut` is not allowed, try wrapping \ this type into `owned({ty}), ref({ty}), ref_mut({ty})`", ty = ty.into_token_stream(), ), )) } else { Ok(out) } } } /// `#[into(skip)]` field attribute. struct SkipFieldAttribute; impl SkipFieldAttribute { /// Parses a [`SkipFieldAttribute`] from the provided [`syn::Attribute`]s. fn parse_attrs(attrs: impl AsRef<[syn::Attribute]>) -> syn::Result> { Ok(attrs .as_ref() .iter() .filter(|attr| attr.path().is_ident("into")) .try_fold(None, |mut attrs, attr| { let field_attr = attr.parse_args::()?; if let Some((path, _)) = attrs.replace((attr.path(), field_attr)) { Err(syn::Error::new( path.span(), "only single `#[into(...)]` attribute is allowed here", )) } else { Ok(attrs) } })? .map(|(_, attr)| attr)) } } impl Parse for SkipFieldAttribute { fn parse(content: ParseStream) -> syn::Result { match content.parse::()? { p if p.is_ident("skip") | p.is_ident("ignore") => Ok(Self), p => Err(syn::Error::new( p.span(), format!("expected `skip`, found: `{}`", p.into_token_stream()), )), } } } /// [`Error`]ors for legacy syntax: `#[into(types(i32, "&str"))]`. fn check_legacy_syntax( tokens: ParseStream<'_>, fields: &syn::Fields, ) -> syn::Result<()> { let span = tokens.span(); let tokens = tokens.fork(); let map_ty = |s: String| { if fields.len() > 1 { format!( "({})", (0..fields.len()) .map(|_| s.as_str()) .collect::>() .join(", ") ) } else { s } }; let field = match fields.len() { 0 => None, 1 => Some( fields .iter() .next() .unwrap_or_else(|| unreachable!("fields.len() == 1")) .ty .to_token_stream() .to_string(), ), _ => Some(format!( "({})", fields .iter() .map(|f| f.ty.to_token_stream().to_string()) .collect::>() .join(", ") )), }; let Ok(metas) = tokens.parse_terminated(polyfill::Meta::parse, token::Comma) else { return Ok(()); }; let parse_list = |list: polyfill::MetaList, attrs: &mut Option>| { if !list.path.is_ident("types") { return None; } for meta in list .parse_args_with(Punctuated::<_, token::Comma>::parse_terminated) .ok()? { attrs.get_or_insert_with(Vec::new).push(match meta { polyfill::NestedMeta::Lit(syn::Lit::Str(str)) => str.value(), polyfill::NestedMeta::Meta(polyfill::Meta::Path(path)) => { path.into_token_stream().to_string() } _ => return None, }) } Some(()) }; let Some((top_level, owned, ref_, ref_mut)) = metas .into_iter() .try_fold( (None, None, None, None), |(mut top_level, mut owned, mut ref_, mut ref_mut), meta| { let is = |name| { matches!(&meta, polyfill::Meta::Path(p) if p.is_ident(name)) || matches!(&meta, polyfill::Meta::List(list) if list.path.is_ident(name)) }; let parse_inner = |meta, attrs: &mut Option<_>| { match meta { polyfill::Meta::Path(_) => { let _ = attrs.get_or_insert_with(Vec::new); Some(()) } polyfill::Meta::List(list) => { if let polyfill::NestedMeta::Meta(polyfill::Meta::List(list)) = list .parse_args_with(Punctuated::<_, token::Comma>::parse_terminated) .ok()? .pop()? .into_value() { parse_list(list, attrs) } else { None } } } }; match meta { meta if is("owned") => parse_inner(meta, &mut owned), meta if is("ref") => parse_inner(meta, &mut ref_), meta if is("ref_mut") => parse_inner(meta, &mut ref_mut), polyfill::Meta::List(list) => parse_list(list, &mut top_level), _ => None, } .map(|_| (top_level, owned, ref_, ref_mut)) }, ) .filter(|(top_level, owned, ref_, ref_mut)| { [top_level, owned, ref_, ref_mut] .into_iter() .any(|l| l.as_ref().map_or(false, |l| !l.is_empty())) }) else { return Ok(()); }; if [&owned, &ref_, &ref_mut].into_iter().any(Option::is_some) { let format = |list: Option>, name: &str| match list { Some(l) if top_level.as_ref().map_or(true, Vec::is_empty) && l.is_empty() => { Some(name.to_owned()) } Some(l) => Some(format!( "{}({})", name, l.into_iter() .chain(top_level.clone().into_iter().flatten()) .map(map_ty) .chain(field.clone()) .collect::>() .join(", "), )), None => None, }; let format = [ format(owned, "owned"), format(ref_, "ref"), format(ref_mut, "ref_mut"), ] .into_iter() .flatten() .collect::>() .join(", "); Err(syn::Error::new( span, format!("legacy syntax, use `{format}` instead"), )) } else { Err(syn::Error::new( span, format!( "legacy syntax, remove `types` and use `{}` instead", top_level.unwrap_or_else(|| unreachable!()).join(", "), ), )) } }