Debian Codegraph @

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

raw
1 use crate::utils::{DeriveType, HashMap};
2 use crate::utils::{SingleFieldData, State};
3 use proc_macro2::TokenStream;
4 use quote::quote;
5 use syn::{parse::Result, DeriveInput};
6
7 /// Provides the hook to expand `#[derive(FromStr)]` into an implementation of `FromStr`
8 pub fn expand(input: &DeriveInput, trait_name: &'static str) -> Result<TokenStream> {
9 let state = State::new(input, trait_name, trait_name.to_lowercase())?;
10
11 if state.derive_type == DeriveType::Enum {
12 Ok(enum_from(input, state, trait_name))
13 } else {
14 Ok(struct_from(&state, trait_name))
15 }
16 }
17
18 pub fn struct_from(state: &State, trait_name: &'static str) -> TokenStream {
19 // We cannot set defaults for fields, once we do we can remove this check
20 if state.fields.len() != 1 || state.enabled_fields().len() != 1 {
21 panic_one_field(trait_name);
22 }
23
24 let single_field_data = state.assert_single_enabled_field();
25 let SingleFieldData {
26 input_type,
27 field_type,
28 trait_path,
29 casted_trait,
30 impl_generics,
31 ty_generics,
32 where_clause,
33 ..
34 } = single_field_data.clone();
35
36 let initializers = [quote! { #casted_trait::from_str(src)? }];
37 let body = single_field_data.initializer(&initializers);
38
39 quote! {
40 #[automatically_derived]
41 impl #impl_generics #trait_path for #input_type #ty_generics #where_clause {
42 type Err = <#field_type as #trait_path>::Err;
43
44 #[inline]
45 fn from_str(src: &str) -> ::core::result::Result<Self, Self::Err> {
46 Ok(#body)
47 }
48 }
49 }
50 }
51
52 fn enum_from(
53 input: &DeriveInput,
54 state: State,
55 trait_name: &'static str,
56 ) -> TokenStream {
57 let mut variants_caseinsensitive = HashMap::default();
58 for variant_state in state.enabled_variant_data().variant_states {
59 let variant = variant_state.variant.unwrap();
60 if !variant.fields.is_empty() {
61 panic!("Only enums with no fields can derive({trait_name})")
62 }
63
64 variants_caseinsensitive
65 .entry(variant.ident.to_string().to_lowercase())
66 .or_insert_with(Vec::new)
67 .push(variant.ident.clone());
68 }
69
70 let input_type = &input.ident;
71 let input_type_name = input_type.to_string();
72
73 let mut cases = vec![];
74
75 // if a case insensitive match is unique match do that
76 // otherwise do a case sensitive match
77 for (ref canonical, ref variants) in variants_caseinsensitive {
78 if variants.len() == 1 {
79 let variant = &variants[0];
80 cases.push(quote! {
81 #canonical => #input_type::#variant,
82 })
83 } else {
84 for variant in variants {
85 let variant_str = variant.to_string();
86 cases.push(quote! {
87 #canonical if(src == #variant_str) => #input_type::#variant,
88 })
89 }
90 }
91 }
92
93 let trait_path = state.trait_path;
94
95 quote! {
96 impl #trait_path for #input_type {
97 type Err = ::derive_more::FromStrError;
98
99 #[inline]
100 fn from_str(src: &str) -> ::core::result::Result<Self, Self::Err> {
101 Ok(match src.to_lowercase().as_str() {
102 #(#cases)*
103 _ => return Err(::derive_more::FromStrError::new(#input_type_name)),
104 })
105 }
106 }
107 }
108 }
109
110 fn panic_one_field(trait_name: &str) -> ! {
111 panic!("Only structs with one field can derive({trait_name})")
112 }