Debian Codegraph @

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

raw
1 use crate::add_helpers::{struct_exprs, tuple_exprs};
2 use crate::utils::{
3 add_extra_type_param_bound_op_output, field_idents, named_to_vec, numbered_vars,
4 unnamed_to_vec,
5 };
6 use proc_macro2::TokenStream;
7 use quote::{format_ident, quote, ToTokens};
8 use std::iter;
9 use syn::{Data, DataEnum, DeriveInput, Field, Fields, Ident};
10
11 pub fn expand(input: &DeriveInput, trait_name: &str) -> TokenStream {
12 let trait_name = trait_name.trim_end_matches("Self");
13 let trait_ident = format_ident!("{trait_name}");
14 let method_name = trait_name.to_lowercase();
15 let method_ident = format_ident!("{method_name}");
16 let input_type = &input.ident;
17
18 let generics = add_extra_type_param_bound_op_output(&input.generics, &trait_ident);
19 let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
20
21 let (output_type, block) = match input.data {
22 Data::Struct(ref data_struct) => match data_struct.fields {
23 Fields::Unnamed(ref fields) => (
24 quote! { #input_type #ty_generics },
25 tuple_content(input_type, &unnamed_to_vec(fields), &method_ident),
26 ),
27 Fields::Named(ref fields) => (
28 quote! { #input_type #ty_generics },
29 struct_content(input_type, &named_to_vec(fields), &method_ident),
30 ),
31 _ => panic!("Unit structs cannot use derive({trait_name})"),
32 },
33 Data::Enum(ref data_enum) => (
34 quote! {
35 ::core::result::Result<#input_type #ty_generics, ::derive_more::ops::BinaryError>
36 },
37 enum_content(input_type, data_enum, &method_ident),
38 ),
39
40 _ => panic!("Only structs and enums can use derive({trait_name})"),
41 };
42
43 quote! {
44 #[automatically_derived]
45 impl #impl_generics ::derive_more::#trait_ident for #input_type #ty_generics #where_clause {
46 type Output = #output_type;
47
48 #[inline]
49 fn #method_ident(self, rhs: #input_type #ty_generics) -> #output_type {
50 #block
51 }
52 }
53 }
54 }
55
56 fn tuple_content<T: ToTokens>(
57 input_type: &T,
58 fields: &[&Field],
59 method_ident: &Ident,
60 ) -> TokenStream {
61 let exprs = tuple_exprs(fields, method_ident);
62 quote! { #input_type(#(#exprs),*) }
63 }
64
65 fn struct_content(
66 input_type: &Ident,
67 fields: &[&Field],
68 method_ident: &Ident,
69 ) -> TokenStream {
70 // It's safe to unwrap because struct fields always have an identifier
71 let exprs = struct_exprs(fields, method_ident);
72 let field_names = field_idents(fields);
73
74 quote! { #input_type{#(#field_names: #exprs),*} }
75 }
76
77 #[allow(clippy::cognitive_complexity)]
78 fn enum_content(
79 input_type: &Ident,
80 data_enum: &DataEnum,
81 method_ident: &Ident,
82 ) -> TokenStream {
83 let mut matches = vec![];
84 let mut method_iter = iter::repeat(method_ident);
85
86 for variant in &data_enum.variants {
87 let subtype = &variant.ident;
88 let subtype = quote! { #input_type::#subtype };
89
90 match variant.fields {
91 Fields::Unnamed(ref fields) => {
92 // The pattern that is outputted should look like this:
93 // (Subtype(left_vars), TypePath(right_vars)) => Ok(TypePath(exprs))
94 let size = unnamed_to_vec(fields).len();
95 let l_vars = &numbered_vars(size, "l_");
96 let r_vars = &numbered_vars(size, "r_");
97 let method_iter = method_iter.by_ref();
98 let matcher = quote! {
99 (#subtype(#(#l_vars),*),
100 #subtype(#(#r_vars),*)) => {
101 ::core::result::Result::Ok(#subtype(#(#l_vars.#method_iter(#r_vars)),*))
102 }
103 };
104 matches.push(matcher);
105 }
106 Fields::Named(ref fields) => {
107 // The pattern that is outputted should look like this:
108 // (Subtype{a: __l_a, ...}, Subtype{a: __r_a, ...} => {
109 // Ok(Subtype{a: __l_a.add(__r_a), ...})
110 // }
111 let field_vec = named_to_vec(fields);
112 let size = field_vec.len();
113 let field_names = &field_idents(&field_vec);
114 let l_vars = &numbered_vars(size, "l_");
115 let r_vars = &numbered_vars(size, "r_");
116 let method_iter = method_iter.by_ref();
117 let matcher = quote! {
118 (#subtype{#(#field_names: #l_vars),*},
119 #subtype{#(#field_names: #r_vars),*}) => {
120 ::core::result::Result::Ok(#subtype{#(#field_names: #l_vars.#method_iter(#r_vars)),*})
121 }
122 };
123 matches.push(matcher);
124 }
125 Fields::Unit => {
126 let operation_name = method_ident.to_string();
127 matches.push(quote! {
128 (#subtype, #subtype) => ::core::result::Result::Err(
129 ::derive_more::ops::BinaryError::Unit(
130 ::derive_more::ops::UnitError::new(#operation_name)
131 )
132 )
133 });
134 }
135 }
136 }
137
138 if data_enum.variants.len() > 1 {
139 // In the strange case where there's only one enum variant this is would be an unreachable
140 // match.
141 let operation_name = method_ident.to_string();
142 matches.push(quote! {
143 _ => ::core::result::Result::Err(::derive_more::ops::BinaryError::Mismatch(
144 ::derive_more::ops::WrongVariantError::new(#operation_name)
145 ))
146 });
147 }
148 quote! {
149 match (self, rhs) {
150 #(#matches),*
151 }
152 }
153 }