derive_more_impl/
try_into.rs

1use crate::utils::{
2    add_extra_generic_param, numbered_vars, AttrParams, DeriveType, MultiFieldData,
3    State,
4};
5use proc_macro2::TokenStream;
6use quote::{quote, ToTokens};
7use syn::{DeriveInput, Result};
8
9use crate::utils::HashMap;
10
11/// Provides the hook to expand `#[derive(TryInto)]` into an implementation of `TryInto`
12#[allow(clippy::cognitive_complexity)]
13pub 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_data) 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_data {
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_data
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 error = quote! {
103            derive_more::TryIntoError<#reference_with_lifetime #input_type #ty_generics>
104        };
105
106        let try_from = quote! {
107            #[automatically_derived]
108            impl #impl_generics derive_more::core::convert::TryFrom<
109                #reference_with_lifetime #input_type #ty_generics
110            > for (#(#reference_with_lifetime #original_types),*) #where_clause {
111                type Error = #error;
112
113                #[inline]
114                fn try_from(
115                    value: #reference_with_lifetime #input_type #ty_generics,
116                ) -> derive_more::core::result::Result<Self, #error> {
117                    match value {
118                        #(#matchers)|* => derive_more::core::result::Result::Ok(#vars),
119                        _ => derive_more::core::result::Result::Err(
120                            derive_more::TryIntoError::new(value, #variant_names, #output_type),
121                        ),
122                    }
123                }
124            }
125        };
126        try_from.to_tokens(&mut tokens)
127    }
128    Ok(tokens)
129}
derive_more_impl/try_into.rs

derive_more_impl/
try_into.rs
