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
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
|
use proc_macro::TokenStream;
use quote::quote;
use syn::{parse, parse_macro_input};
mod factory_type_alias;
mod injectable_impl;
mod injectable_macro_args;
mod libs;
use factory_type_alias::FactoryTypeAlias;
use injectable_impl::InjectableImpl;
use injectable_macro_args::InjectableMacroArgs;
use libs::intertrait_macros::{
args::{Casts, Flag, Targets},
gen_caster::generate_caster,
};
/// Makes a struct injectable. Thereby usable with `DIContainer`.
///
/// # Arguments
///
/// * A interface trait the struct implements.
///
/// # Examples
/// ```
/// trait IConfigReader
/// {
/// fn read_config(&self) -> Config;
/// }
///
/// struct ConfigReader
/// {
/// _file_reader: InterfacePtr<IFileReader>,
/// }
///
/// impl ConfigReader
/// {
/// fn new(file_reader: InterfacePtr<IFileReader>) -> Self
/// {
/// Self {
/// _file_reader: file_reader
/// }
/// }
/// }
///
/// #[injectable(IConfigReader)]
/// impl IConfigReader for ConfigReader
/// {
/// fn read_config(&self) -> Config
/// {
/// // Stuff here
/// }
/// }
/// ```
#[proc_macro_attribute]
pub fn injectable(args_stream: TokenStream, impl_stream: TokenStream) -> TokenStream
{
let InjectableMacroArgs {
interface: interface_type_path,
} = parse_macro_input!(args_stream);
let injectable_impl: InjectableImpl = parse(impl_stream).unwrap();
let expanded_injectable_impl = injectable_impl.expand();
let self_type = &injectable_impl.self_type;
quote! {
#expanded_injectable_impl
syrette::castable_to!(#self_type => #interface_type_path);
}
.into()
}
/// Makes a type alias usable as a factory interface.
///
/// # Examples
/// ```
/// trait IUser
/// {
/// fn name(&self) -> String;
/// fn age(&self) -> i32;
/// }
///
/// struct User
/// {
/// _name: String,
/// _age: i32,
/// }
///
/// impl User
/// {
/// fn new(name: String, age: i32) -> Self
/// {
/// Self {
/// _name: name,
/// _age: age,
/// }
/// }
/// }
///
/// impl IUser for User
/// {
/// fn name(&self) -> String
/// {
/// self._name
/// }
///
/// fn age(&self) -> i32
/// {
/// self._age
/// }
/// }
///
/// type UserFactory = dyn IFactory<(String, i32), dyn IUser>;
/// ```
#[proc_macro_attribute]
pub fn factory(_: TokenStream, type_alias_stream: TokenStream) -> TokenStream
{
let FactoryTypeAlias {
type_alias,
factory_interface,
arg_types,
return_type,
} = parse(type_alias_stream).unwrap();
quote! {
#type_alias
syrette::castable_to!(
syrette::castable_factory::CastableFactory<
#arg_types,
#return_type
> => #factory_interface
);
syrette::castable_to!(
syrette::castable_factory::CastableFactory<
#arg_types,
#return_type
> => syrette::castable_factory::AnyFactory
);
}
.into()
}
#[doc(hidden)]
#[proc_macro]
pub fn castable_to(input: TokenStream) -> TokenStream
{
let Casts {
ty,
targets: Targets { flags, paths },
} = parse_macro_input!(input);
paths
.iter()
.map(|t| generate_caster(&ty, t, flags.contains(&Flag::Sync)))
.collect::<proc_macro2::TokenStream>()
.into()
}
|
