Debian Codegraph @

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

raw
1 use proc_macro2::TokenStream;
2 use quote::quote;
3 use syn::{spanned::Spanned as _, Error, Result};
4
5 use crate::utils::{
6 self, AttrParams, DeriveType, FullMetaInfo, HashSet, MetaInfo, MultiFieldData,
7 State,
8 };
9
10 pub fn expand(
11 input: &syn::DeriveInput,
12 trait_name: &'static str,
13 ) -> Result<TokenStream> {
14 let syn::DeriveInput {
15 ident, generics, ..
16 } = input;
17
18 let state = State::with_attr_params(
19 input,
20 trait_name,
21 trait_name.to_lowercase(),
22 allowed_attr_params(),
23 )?;
24
25 let type_params: HashSet<_> = generics
26 .params
27 .iter()
28 .filter_map(|generic| match generic {
29 syn::GenericParam::Type(ty) => Some(ty.ident.clone()),
30 _ => None,
31 })
32 .collect();
33
34 let (bounds, source, provide) = match state.derive_type {
35 DeriveType::Named | DeriveType::Unnamed => render_struct(&type_params, &state)?,
36 DeriveType::Enum => render_enum(&type_params, &state)?,
37 };
38
39 let source = source.map(|source| {
40 quote! {
41 fn source(&self) -> Option<&(dyn ::derive_more::Error + 'static)> {
42 use ::derive_more::__private::AsDynError;
43 #source
44 }
45 }
46 });
47
48 let provide = provide.map(|provide| {
49 quote! {
50 fn provide<'_demand>(&'_demand self, demand: &mut ::core::any::Demand<'_demand>) {
51 #provide
52 }
53 }
54 });
55
56 let mut generics = generics.clone();
57
58 if !type_params.is_empty() {
59 let (_, ty_generics, _) = generics.split_for_impl();
60 generics = utils::add_extra_where_clauses(
61 &generics,
62 quote! {
63 where
64 #ident #ty_generics: ::core::fmt::Debug + ::core::fmt::Display
65 },
66 );
67 }
68
69 if !bounds.is_empty() {
70 let bounds = bounds.iter();
71 generics = utils::add_extra_where_clauses(
72 &generics,
73 quote! {
74 where
75 #(#bounds: ::core::fmt::Debug + ::core::fmt::Display + ::derive_more::Error + 'static),*
76 },
77 );
78 }
79
80 let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
81
82 let render = quote! {
83 #[automatically_derived]
84 impl #impl_generics ::derive_more::Error for #ident #ty_generics #where_clause {
85 #source
86 #provide
87 }
88 };
89
90 Ok(render)
91 }
92
93 fn render_struct(
94 type_params: &HashSet<syn::Ident>,
95 state: &State,
96 ) -> Result<(HashSet<syn::Type>, Option<TokenStream>, Option<TokenStream>)> {
97 let parsed_fields = parse_fields(type_params, state)?;
98
99 let source = parsed_fields.render_source_as_struct();
100 let provide = parsed_fields.render_provide_as_struct();
101
102 Ok((parsed_fields.bounds, source, provide))
103 }
104
105 fn render_enum(
106 type_params: &HashSet<syn::Ident>,
107 state: &State,
108 ) -> Result<(HashSet<syn::Type>, Option<TokenStream>, Option<TokenStream>)> {
109 let mut bounds = HashSet::default();
110 let mut source_match_arms = Vec::new();
111 let mut provide_match_arms = Vec::new();
112
113 for variant in state.enabled_variant_data().variants {
114 let default_info = FullMetaInfo {
115 enabled: true,
116 ..FullMetaInfo::default()
117 };
118
119 let state = State::from_variant(
120 state.input,
121 state.trait_name,
122 state.trait_attr.clone(),
123 allowed_attr_params(),
124 variant,
125 default_info,
126 )?;
127
128 let parsed_fields = parse_fields(type_params, &state)?;
129
130 if let Some(expr) = parsed_fields.render_source_as_enum_variant_match_arm() {
131 source_match_arms.push(expr);
132 }
133
134 if let Some(expr) = parsed_fields.render_provide_as_enum_variant_match_arm() {
135 provide_match_arms.push(expr);
136 }
137
138 bounds.extend(parsed_fields.bounds.into_iter());
139 }
140
141 let render = |match_arms: &mut Vec<TokenStream>, unmatched| {
142 if !match_arms.is_empty() && match_arms.len() < state.variants.len() {
143 match_arms.push(quote! { _ => #unmatched });
144 }
145
146 (!match_arms.is_empty()).then(|| {
147 quote! {
148 match self {
149 #(#match_arms),*
150 }
151 }
152 })
153 };
154
155 let source = render(&mut source_match_arms, quote! { None });
156 let provide = render(&mut provide_match_arms, quote! { () });
157
158 Ok((bounds, source, provide))
159 }
160
161 fn allowed_attr_params() -> AttrParams {
162 AttrParams {
163 enum_: vec!["ignore"],
164 struct_: vec!["ignore"],
165 variant: vec!["ignore"],
166 field: vec!["ignore", "source", "backtrace"],
167 }
168 }
169
170 struct ParsedFields<'input, 'state> {
171 data: MultiFieldData<'input, 'state>,
172 source: Option<usize>,
173 backtrace: Option<usize>,
174 bounds: HashSet<syn::Type>,
175 }
176
177 impl<'input, 'state> ParsedFields<'input, 'state> {
178 fn new(data: MultiFieldData<'input, 'state>) -> Self {
179 Self {
180 data,
181 source: None,
182 backtrace: None,
183 bounds: HashSet::default(),
184 }
185 }
186 }
187
188 impl<'input, 'state> ParsedFields<'input, 'state> {
189 fn render_source_as_struct(&self) -> Option<TokenStream> {
190 let source = self.source?;
191 let ident = &self.data.members[source];
192 Some(render_some(quote! { #ident }))
193 }
194
195 fn render_source_as_enum_variant_match_arm(&self) -> Option<TokenStream> {
196 let source = self.source?;
197 let pattern = self.data.matcher(&[source], &[quote! { source }]);
198 let expr = render_some(quote! { source });
199 Some(quote! { #pattern => #expr })
200 }
201
202 fn render_provide_as_struct(&self) -> Option<TokenStream> {
203 let backtrace = self.backtrace?;
204
205 let source_provider = self.source.map(|source| {
206 let source_expr = &self.data.members[source];
207 quote! {
208 ::derive_more::Error::provide(&#source_expr, demand);
209 }
210 });
211 let backtrace_provider = self
212 .source
213 .filter(|source| *source == backtrace)
214 .is_none()
215 .then(|| {
216 let backtrace_expr = &self.data.members[backtrace];
217 quote! {
218 demand.provide_ref::<::std::backtrace::Backtrace>(&#backtrace_expr);
219 }
220 });
221
222 (source_provider.is_some() || backtrace_provider.is_some()).then(|| {
223 quote! {
224 #backtrace_provider
225 #source_provider
226 }
227 })
228 }
229
230 fn render_provide_as_enum_variant_match_arm(&self) -> Option<TokenStream> {
231 let backtrace = self.backtrace?;
232
233 match self.source {
234 Some(source) if source == backtrace => {
235 let pattern = self.data.matcher(&[source], &[quote! { source }]);
236 Some(quote! {
237 #pattern => {
238 ::derive_more::Error::provide(source, demand);
239 }
240 })
241 }
242 Some(source) => {
243 let pattern = self.data.matcher(
244 &[source, backtrace],
245 &[quote! { source }, quote! { backtrace }],
246 );
247 Some(quote! {
248 #pattern => {
249 demand.provide_ref::<::std::backtrace::Backtrace>(backtrace);
250 ::derive_more::Error::provide(source, demand);
251 }
252 })
253 }
254 None => {
255 let pattern = self.data.matcher(&[backtrace], &[quote! { backtrace }]);
256 Some(quote! {
257 #pattern => {
258 demand.provide_ref::<::std::backtrace::Backtrace>(backtrace);
259 }
260 })
261 }
262 }
263 }
264 }
265
266 fn render_some<T>(expr: T) -> TokenStream
267 where
268 T: quote::ToTokens,
269 {
270 quote! { Some(#expr.as_dyn_error()) }
271 }
272
273 fn parse_fields<'input, 'state>(
274 type_params: &HashSet<syn::Ident>,
275 state: &'state State<'input>,
276 ) -> Result<ParsedFields<'input, 'state>> {
277 let mut parsed_fields = match state.derive_type {
278 DeriveType::Named => {
279 parse_fields_impl(state, |attr, field, _| {
280 // Unwrapping is safe, cause fields in named struct
281 // always have an ident
282 let ident = field.ident.as_ref().unwrap();
283
284 match attr {
285 "source" => ident == "source",
286 "backtrace" => {
287 ident == "backtrace"
288 || is_type_path_ends_with_segment(&field.ty, "Backtrace")
289 }
290 _ => unreachable!(),
291 }
292 })
293 }
294
295 DeriveType::Unnamed => {
296 let mut parsed_fields =
297 parse_fields_impl(state, |attr, field, len| match attr {
298 "source" => {
299 len == 1
300 && !is_type_path_ends_with_segment(&field.ty, "Backtrace")
301 }
302 "backtrace" => {
303 is_type_path_ends_with_segment(&field.ty, "Backtrace")
304 }
305 _ => unreachable!(),
306 })?;
307
308 parsed_fields.source = parsed_fields
309 .source
310 .or_else(|| infer_source_field(&state.fields, &parsed_fields));
311
312 Ok(parsed_fields)
313 }
314
315 _ => unreachable!(),
316 }?;
317
318 if let Some(source) = parsed_fields.source {
319 add_bound_if_type_parameter_used_in_type(
320 &mut parsed_fields.bounds,
321 type_params,
322 &state.fields[source].ty,
323 );
324 }
325
326 Ok(parsed_fields)
327 }
328
329 /// Checks if `ty` is [`syn::Type::Path`] and ends with segment matching `tail`
330 /// and doesn't contain any generic parameters.
331 fn is_type_path_ends_with_segment(ty: &syn::Type, tail: &str) -> bool {
332 let syn::Type::Path(ty) = ty else {
333 return false;
334 };
335
336 // Unwrapping is safe, cause 'syn::TypePath.path.segments'
337 // have to have at least one segment
338 let segment = ty.path.segments.last().unwrap();
339
340 if !matches!(segment.arguments, syn::PathArguments::None) {
341 return false;
342 }
343
344 segment.ident == tail
345 }
346
347 fn infer_source_field(
348 fields: &[&syn::Field],
349 parsed_fields: &ParsedFields,
350 ) -> Option<usize> {
351 // if we have exactly two fields
352 if fields.len() != 2 {
353 return None;
354 }
355
356 // no source field was specified/inferred
357 if parsed_fields.source.is_some() {
358 return None;
359 }
360
361 // but one of the fields was specified/inferred as backtrace field
362 if let Some(backtrace) = parsed_fields.backtrace {
363 // then infer *other field* as source field
364 let source = (backtrace + 1) % 2;
365 // unless it was explicitly marked as non-source
366 if parsed_fields.data.infos[source].info.source != Some(false) {
367 return Some(source);
368 }
369 }
370
371 None
372 }
373
374 fn parse_fields_impl<'input, 'state, P>(
375 state: &'state State<'input>,
376 is_valid_default_field_for_attr: P,
377 ) -> Result<ParsedFields<'input, 'state>>
378 where
379 P: Fn(&str, &syn::Field, usize) -> bool,
380 {
381 let MultiFieldData { fields, infos, .. } = state.enabled_fields_data();
382
383 let iter = fields
384 .iter()
385 .zip(infos.iter().map(|info| &info.info))
386 .enumerate()
387 .map(|(index, (field, info))| (index, *field, info));
388
389 let source = parse_field_impl(
390 &is_valid_default_field_for_attr,
391 state.fields.len(),
392 iter.clone(),
393 "source",
394 |info| info.source,
395 )?;
396
397 let backtrace = parse_field_impl(
398 &is_valid_default_field_for_attr,
399 state.fields.len(),
400 iter.clone(),
401 "backtrace",
402 |info| info.backtrace,
403 )?;
404
405 let mut parsed_fields = ParsedFields::new(state.enabled_fields_data());
406
407 if let Some((index, _, _)) = source {
408 parsed_fields.source = Some(index);
409 }
410
411 if let Some((index, _, _)) = backtrace {
412 parsed_fields.backtrace = Some(index);
413 }
414
415 Ok(parsed_fields)
416 }
417
418 fn parse_field_impl<'a, P, V>(
419 is_valid_default_field_for_attr: &P,
420 len: usize,
421 iter: impl Iterator<Item = (usize, &'a syn::Field, &'a MetaInfo)> + Clone,
422 attr: &str,
423 value: V,
424 ) -> Result<Option<(usize, &'a syn::Field, &'a MetaInfo)>>
425 where
426 P: Fn(&str, &syn::Field, usize) -> bool,
427 V: Fn(&MetaInfo) -> Option<bool>,
428 {
429 let explicit_fields = iter
430 .clone()
431 .filter(|(_, _, info)| matches!(value(info), Some(true)));
432
433 let inferred_fields = iter.filter(|(_, field, info)| match value(info) {
434 None => is_valid_default_field_for_attr(attr, field, len),
435 _ => false,
436 });
437
438 let field = assert_iter_contains_zero_or_one_item(
439 explicit_fields,
440 &format!(
441 "Multiple `{attr}` attributes specified. \
442 Single attribute per struct/enum variant allowed.",
443 ),
444 )?;
445
446 let field = match field {
447 field @ Some(_) => field,
448 None => assert_iter_contains_zero_or_one_item(
449 inferred_fields,
450 "Conflicting fields found. Consider specifying some \
451 `#[error(...)]` attributes to resolve conflict.",
452 )?,
453 };
454
455 Ok(field)
456 }
457
458 fn assert_iter_contains_zero_or_one_item<'a>(
459 mut iter: impl Iterator<Item = (usize, &'a syn::Field, &'a MetaInfo)>,
460 error_msg: &str,
461 ) -> Result<Option<(usize, &'a syn::Field, &'a MetaInfo)>> {
462 let Some(item) = iter.next() else {
463 return Ok(None);
464 };
465
466 if let Some((_, field, _)) = iter.next() {
467 return Err(Error::new(field.span(), error_msg));
468 }
469
470 Ok(Some(item))
471 }
472
473 fn add_bound_if_type_parameter_used_in_type(
474 bounds: &mut HashSet<syn::Type>,
475 type_params: &HashSet<syn::Ident>,
476 ty: &syn::Type,
477 ) {
478 if let Some(ty) = utils::get_if_type_parameter_used_in_type(type_params, ty) {
479 bounds.insert(ty);
480 }
481 }