derive_tools_meta 0.63.0

Collection of derives which extend STD. Its meta module. Don't use directly.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

use macro_tools ::
{
  diag, generic_params, item_struct, struct_like ::StructLike, Result, qt, attr, syn, proc_macro2, return_syn_err, Spanned,
};

use super ::item_attributes :: { ItemAttributes };

///
/// Derive macro to implement `InnerFrom` when-ever it's possible to do automatically.
///
pub fn inner_from(input: proc_macro ::TokenStream) -> Result< proc_macro2 ::TokenStream > 
{
  let original_input = input.clone();
  let parsed = syn ::parse :: < StructLike >(input)?;
  let has_debug = attr ::has_debug(parsed.attrs().iter())?;
  let _item_attrs = ItemAttributes ::from_attrs(parsed.attrs().iter())?;
  let item_name = &parsed.ident();

  let (_generics_with_defaults, generics_impl, generics_ty, generics_where) = generic_params ::decompose(parsed.generics());

  let result =  match parsed 
  {
  StructLike ::Unit(ref _item) =>
  {
   return_syn_err!(parsed.span(), "Expects a structure with one field");
 }
  StructLike ::Struct(ref item) =>
  {
   let field_type = item_struct ::first_field_type(item)?;
   let field_name = item_struct ::first_field_name(item).ok().flatten();
   generate(
  item_name,
  &generics_impl,
  &generics_ty,
  &generics_where,
  &field_type,
  field_name.as_ref(),
 )
 }
  StructLike ::Enum(ref item) =>
  {
   return_syn_err!(item.span(), "InnerFrom can be applied only to a structure");
 }
 };

  if has_debug 
  {
  let about = format!("derive: InnerFrom\nstructure: {item_name}");
  diag ::report_print(about, &original_input, &result);
 }

  Ok(result)
}

/// Generates `inner_from()` inherent method for structs.
///
/// Fix(issue-3): Changed from trait implementation to inherent method.
/// Root cause: Original implementation generated `impl crate::InnerFrom` for non-existent trait.
/// Pitfall: Proc macros that generate trait implementations must verify the trait exists and is in scope. Inherent implementations are safer for utility methods like constructors.
///
/// Example of generated code :
/// ```text
/// impl IsTransparent
/// {
///   pub fn inner_from( src: bool ) -> Self
///   {
///     Self( src )
/// }
/// }
/// ```
fn generate(
  item_name: &syn ::Ident,
  generics_impl: &syn ::punctuated ::Punctuated< syn ::GenericParam, syn ::token ::Comma >,
  generics_ty: &syn ::punctuated ::Punctuated< syn ::GenericParam, syn ::token ::Comma >,
  generics_where: &syn ::punctuated ::Punctuated< syn ::WherePredicate, syn ::token ::Comma >,
  field_type: &syn ::Type,
  field_name: Option< &syn ::Ident >,
) -> proc_macro2 ::TokenStream {
  let body =  if let Some(field_name) = field_name
  {
  qt! { Self { #field_name: src } }
 } else {
  qt! { Self( src ) }
 };

  qt! {
  #[ automatically_derived ]
  impl< #generics_impl > #item_name< #generics_ty >
  where
   #generics_where
  {
   #[ inline( always ) ]
   pub fn inner_from( src: #field_type ) -> Self
   {
  #body
 }
 }
 }
}