| 1 |
use crate::utils::{ |
| 2 |
add_extra_generic_param, numbered_vars, AttrParams, DeriveType, MultiFieldData, |
| 3 |
State, |
| 4 |
}; |
| 5 |
use proc_macro2::TokenStream; |
| 6 |
use quote::{quote, ToTokens}; |
| 7 |
use syn::{DeriveInput, Result}; |
| 8 |
|
| 9 |
use crate::utils::HashMap; |
| 10 |
|
| 11 |
/// Provides the hook to expand `#[derive(TryInto)]` into an implementation of `TryInto` |
| 12 |
#[allow(clippy::cognitive_complexity)] |
| 13 |
pub fn expand(input: &DeriveInput, trait_name: &'static str) -> Result<TokenStream> { |
| 14 |
let state = State::with_attr_params( |
| 15 |
input, |
| 16 |
trait_name, |
| 17 |
"try_into".into(), |
| 18 |
AttrParams { |
| 19 |
enum_: vec!["ignore", "owned", "ref", "ref_mut"], |
| 20 |
variant: vec!["ignore", "owned", "ref", "ref_mut"], |
| 21 |
struct_: vec!["ignore", "owned", "ref", "ref_mut"], |
| 22 |
field: vec!["ignore"], |
| 23 |
}, |
| 24 |
)?; |
| 25 |
assert!( |
| 26 |
state.derive_type == DeriveType::Enum, |
| 27 |
"Only enums can derive TryInto" |
| 28 |
); |
| 29 |
|
| 30 |
let mut variants_per_types = HashMap::default(); |
| 31 |
|
| 32 |
for variant_state in state.enabled_variant_data().variant_states { |
| 33 |
let multi_field_data = variant_state.enabled_fields_data(); |
| 34 |
let MultiFieldData { |
| 35 |
variant_info, |
| 36 |
field_types, |
| 37 |
.. |
| 38 |
} = multi_field_data.clone(); |
| 39 |
for ref_type in variant_info.ref_types() { |
| 40 |
variants_per_types |
| 41 |
.entry((ref_type, field_types.clone())) |
| 42 |
.or_insert_with(Vec::new) |
| 43 |
.push(multi_field_data.clone()); |
| 44 |
} |
| 45 |
} |
| 46 |
|
| 47 |
let mut tokens = TokenStream::new(); |
| 48 |
|
| 49 |
for ((ref_type, ref original_types), ref multi_field_datas) in variants_per_types { |
| 50 |
let input_type = &input.ident; |
| 51 |
|
| 52 |
let pattern_ref = ref_type.pattern_ref(); |
| 53 |
let lifetime = ref_type.lifetime(); |
| 54 |
let reference_with_lifetime = ref_type.reference_with_lifetime(); |
| 55 |
|
| 56 |
let mut matchers = vec![]; |
| 57 |
let vars = &numbered_vars(original_types.len(), ""); |
| 58 |
for multi_field_data in multi_field_datas { |
| 59 |
let patterns: Vec<_> = vars |
| 60 |
.iter() |
| 61 |
.map(|var| quote! { #pattern_ref #var }) |
| 62 |
.collect(); |
| 63 |
matchers.push( |
| 64 |
multi_field_data.matcher(&multi_field_data.field_indexes, &patterns), |
| 65 |
); |
| 66 |
} |
| 67 |
|
| 68 |
let vars = if vars.len() == 1 { |
| 69 |
quote! { #(#vars)* } |
| 70 |
} else { |
| 71 |
quote! { (#(#vars),*) } |
| 72 |
}; |
| 73 |
|
| 74 |
let output_type = if original_types.len() == 1 { |
| 75 |
quote! { #(#original_types)* }.to_string() |
| 76 |
} else { |
| 77 |
let types = original_types |
| 78 |
.iter() |
| 79 |
.map(|t| quote! { #t }.to_string()) |
| 80 |
.collect::<Vec<_>>(); |
| 81 |
format!("({})", types.join(", ")) |
| 82 |
}; |
| 83 |
let variant_names = multi_field_datas |
| 84 |
.iter() |
| 85 |
.map(|d| { |
| 86 |
d.variant_name |
| 87 |
.expect("Somehow there was no variant name") |
| 88 |
.to_string() |
| 89 |
}) |
| 90 |
.collect::<Vec<_>>() |
| 91 |
.join(", "); |
| 92 |
|
| 93 |
let generics_impl; |
| 94 |
let (_, ty_generics, where_clause) = input.generics.split_for_impl(); |
| 95 |
let (impl_generics, _, _) = if ref_type.is_ref() { |
| 96 |
generics_impl = add_extra_generic_param(&input.generics, lifetime.clone()); |
| 97 |
generics_impl.split_for_impl() |
| 98 |
} else { |
| 99 |
input.generics.split_for_impl() |
| 100 |
}; |
| 101 |
|
| 102 |
let try_from = quote! { |
| 103 |
#[automatically_derived] |
| 104 |
impl #impl_generics |
| 105 |
::core::convert::TryFrom<#reference_with_lifetime #input_type #ty_generics> for |
| 106 |
(#(#reference_with_lifetime #original_types),*) |
| 107 |
#where_clause |
| 108 |
{ |
| 109 |
type Error = ::derive_more::TryIntoError<#reference_with_lifetime #input_type>; |
| 110 |
|
| 111 |
#[inline] |
| 112 |
fn try_from(value: #reference_with_lifetime #input_type #ty_generics) -> ::core::result::Result<Self, Self::Error> { |
| 113 |
match value { |
| 114 |
#(#matchers)|* => ::core::result::Result::Ok(#vars), |
| 115 |
_ => ::core::result::Result::Err(::derive_more::TryIntoError::new(value, #variant_names, #output_type)), |
| 116 |
} |
| 117 |
} |
| 118 |
} |
| 119 |
}; |
| 120 |
try_from.to_tokens(&mut tokens) |
| 121 |
} |
| 122 |
Ok(tokens) |
| 123 |
} |