1 //! Macros that should be exported from both `darling_core` and `darling`.
2 //! Note that these are **sym-linked** into the main code, and so cannot declare on items that are exported differently
3 //! in `darling_core` vs. `darling`.
4 
5 /// Generator for `UsesTypeParam` impls that unions the used type parameters of the selected fields.
6 ///
7 /// # Usage
8 /// The macro takes the type implementing the trait as the first argument, then a comma-separated list of
9 /// fields for the rest of its arguments.
10 ///
11 /// The type of each passed-in field must implement `UsesTypeParams`, or the resulting code won't compile.
12 ///
13 /// ```rust
14 /// # extern crate syn;
15 /// # use darling_core::uses_type_params;
16 /// #
17 /// struct MyField {
18 ///     ty: syn::Type,
19 /// }
20 ///
21 /// uses_type_params!(MyField, ty);
22 ///
23 /// fn main() {
24 ///     // no test run
25 /// }
26 /// ```
27 ///
28 /// `darling` cannot derive this trait automatically, as it doesn't know which information extracted from
29 /// proc-macro input is meant to constitute "using" the type parameter, but crate consumers should
30 /// implement it by hand or using the macro.
31 #[macro_export]
32 macro_rules! uses_type_params {
33     ($impl_type:ty, $accessor:ident) => {
34         impl $crate::usage::UsesTypeParams for $impl_type {
35             fn uses_type_params<'gen>(
36                 &self,
37                 options: &$crate::usage::Options,
38                 type_set: &'gen $crate::usage::IdentSet
39             ) -> $crate::usage::IdentRefSet<'gen> {
40                 self.$accessor.uses_type_params(options, type_set)
41             }
42         }
43     };
44     ($impl_type:ty, $first:ident, $($field:ident),+) => {
45         impl $crate::usage::UsesTypeParams for $impl_type {
46             fn uses_type_params<'gen>(
47                 &self,
48                 options: &$crate::usage::Options,
49                 type_set: &'gen $crate::usage::IdentSet
50             ) -> $crate::usage::IdentRefSet<'gen> {
51                 let mut hits = self.$first.uses_type_params(options, type_set);
52                 $(
53                     hits.extend(self.$field.uses_type_params(options, type_set));
54                 )*
55                 hits
56             }
57         }
58     };
59 }
60 
61 /// Generator for `UsesLifetimes` impls that unions the used lifetimes of the selected fields.
62 ///
63 /// # Usage
64 /// The macro takes the type implementing the trait as the first argument, then a comma-separated list of
65 /// fields for the rest of its arguments.
66 ///
67 /// The type of each passed-in field must implement `UsesLifetimes`, or the resulting code won't compile.
68 #[macro_export]
69 macro_rules! uses_lifetimes {
70     ($impl_type:ty, $accessor:ident) => {
71         impl $crate::usage::UsesLifetimes for $impl_type {
72             fn uses_lifetimes<'gen>(
73                 &self,
74                 options: &$crate::usage::Options,
75                 type_set: &'gen $crate::usage::LifetimeSet
76             ) -> $crate::usage::LifetimeRefSet<'gen> {
77                 self.$accessor.uses_lifetimes(options, type_set)
78             }
79         }
80     };
81     ($impl_type:ty, $first:ident, $($field:ident),+) => {
82         impl $crate::usage::UsesLifetimes for $impl_type {
83             fn uses_lifetimes<'gen>(
84                 &self,
85                 options: &$crate::usage::Options,
86                 type_set: &'gen $crate::usage::LifetimeSet
87             ) -> $crate::usage::LifetimeRefSet<'gen> {
88                 let mut hits = self.$first.uses_lifetimes(options, type_set);
89                 $(
90                     hits.extend(self.$field.uses_lifetimes(options, type_set));
91                 )*
92                 hits
93             }
94         }
95     };
96 }
97