Debian Codegraph @

third_party/rust/derive_more-impl/src/try_into.rs

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