Debian Codegraph @

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

raw
1 use crate::utils::{AttrParams, DeriveType, State};
2 use convert_case::{Case, Casing};
3 use proc_macro2::TokenStream;
4 use quote::{format_ident, quote};
5 use syn::{DeriveInput, Fields, Ident, Result, Type};
6
7 pub fn expand(input: &DeriveInput, trait_name: &'static str) -> Result<TokenStream> {
8 let state = State::with_attr_params(
9 input,
10 trait_name,
11 "try_unwrap".into(),
12 AttrParams {
13 enum_: vec!["ignore", "owned", "ref", "ref_mut"],
14 variant: vec!["ignore", "owned", "ref", "ref_mut"],
15 struct_: vec!["ignore"],
16 field: vec!["ignore"],
17 },
18 )?;
19 assert!(
20 state.derive_type == DeriveType::Enum,
21 "TryUnwrap can only be derived for enums"
22 );
23
24 let enum_name = &input.ident;
25 let (imp_generics, type_generics, where_clause) = input.generics.split_for_impl();
26
27 let variant_data = state.enabled_variant_data();
28
29 let mut funcs = vec![];
30 for (variant_state, info) in
31 Iterator::zip(variant_data.variant_states.iter(), variant_data.infos)
32 {
33 let variant = variant_state.variant.unwrap();
34 let fn_name = format_ident!(
35 "try_unwrap_{ident}",
36 ident = variant.ident.to_string().to_case(Case::Snake),
37 span = variant.ident.span(),
38 );
39 let ref_fn_name = format_ident!(
40 "try_unwrap_{ident}_ref",
41 ident = variant.ident.to_string().to_case(Case::Snake),
42 span = variant.ident.span(),
43 );
44 let mut_fn_name = format_ident!(
45 "try_unwrap_{ident}_mut",
46 ident = variant.ident.to_string().to_case(Case::Snake),
47 span = variant.ident.span(),
48 );
49 let variant_ident = &variant.ident;
50 let (data_pattern, ret_value, data_types) = get_field_info(&variant.fields);
51 let pattern = quote! { #enum_name :: #variant_ident #data_pattern };
52
53 let (failed_block, failed_block_ref, failed_block_mut) = (
54 failed_block(&state, enum_name, &fn_name),
55 failed_block(&state, enum_name, &ref_fn_name),
56 failed_block(&state, enum_name, &mut_fn_name),
57 );
58
59 let doc_owned = format!(
60 "Attempts to unwrap this value to the `{enum_name}::{variant_ident}` variant.\n",
61 );
62 let doc_ref = format!(
63 "Attempts to unwrap this reference to the `{enum_name}::{variant_ident}` variant.\n",
64 );
65 let doc_mut = format!(
66 "Attempts to unwrap this mutable reference to the `{enum_name}::{variant_ident}` variant.\n",
67 );
68 let doc_else = "Returns a [TryUnwrapError] with the original value if this value is of any other type.";
69 let func = quote! {
70 #[inline]
71 #[track_caller]
72 #[doc = #doc_owned]
73 #[doc = #doc_else]
74 pub fn #fn_name(self) -> Result<(#(#data_types),*), ::derive_more::TryUnwrapError<Self>> {
75 match self {
76 #pattern => Ok(#ret_value),
77 val @ _ => #failed_block,
78 }
79 }
80 };
81
82 let ref_func = quote! {
83 #[inline]
84 #[track_caller]
85 #[doc = #doc_ref]
86 #[doc = #doc_else]
87 pub fn #ref_fn_name(&self) -> Result<(#(&#data_types),*), ::derive_more::TryUnwrapError<&Self>> {
88 match self {
89 #pattern => Ok(#ret_value),
90 val @ _ => #failed_block_ref,
91 }
92 }
93 };
94
95 let mut_func = quote! {
96 #[inline]
97 #[track_caller]
98 #[doc = #doc_mut]
99 #[doc = #doc_else]
100 pub fn #mut_fn_name(&mut self) -> Result<(#(&mut #data_types),*), ::derive_more::TryUnwrapError<&mut Self>> {
101 match self {
102 #pattern => Ok(#ret_value),
103 val @ _ => #failed_block_mut,
104 }
105 }
106 };
107
108 if info.owned && state.default_info.owned {
109 funcs.push(func);
110 }
111 if info.ref_ && state.default_info.ref_ {
112 funcs.push(ref_func);
113 }
114 if info.ref_mut && state.default_info.ref_mut {
115 funcs.push(mut_func);
116 }
117 }
118
119 let imp = quote! {
120 #[automatically_derived]
121 impl #imp_generics #enum_name #type_generics #where_clause {
122 #(#funcs)*
123 }
124 };
125
126 Ok(imp)
127 }
128
129 fn get_field_info(fields: &Fields) -> (TokenStream, TokenStream, Vec<&Type>) {
130 match fields {
131 Fields::Named(_) => panic!("cannot unwrap anonymous records"),
132 Fields::Unnamed(ref fields) => {
133 let (idents, types) = fields
134 .unnamed
135 .iter()
136 .enumerate()
137 .map(|(n, it)| (format_ident!("field_{n}"), &it.ty))
138 .unzip::<_, _, Vec<_>, Vec<_>>();
139 (quote! { (#(#idents),*) }, quote! { (#(#idents),*) }, types)
140 }
141 Fields::Unit => (quote! {}, quote! { () }, vec![]),
142 }
143 }
144
145 fn failed_block(state: &State, enum_name: &Ident, func_name: &Ident) -> TokenStream {
146 let arms = state
147 .variant_states
148 .iter()
149 .map(|it| it.variant.unwrap())
150 .map(|variant| {
151 let data_pattern = match variant.fields {
152 Fields::Named(_) => quote! { {..} },
153 Fields::Unnamed(_) => quote! { (..) },
154 Fields::Unit => quote! {},
155 };
156 let variant_ident = &variant.ident;
157 let error = quote! { ::derive_more::TryUnwrapError::<_>::new(val, stringify!(#enum_name), stringify!(#variant_ident), stringify!(#func_name)) };
158 quote! { val @ #enum_name :: #variant_ident #data_pattern => Err(#error) }
159 });
160
161 quote! {
162 match val {
163 #(#arms),*
164 }
165 }
166 }