1mod aggregate;
2mod attribute;
3mod bootstrap;
4mod constants;
5mod convert;
6mod equal;
7mod field;
8mod filter;
9mod group;
10mod hashedby;
11mod leftright;
12mod orderedby;
13mod pipemeta;
14mod project;
15mod render;
16mod utils;
17
18use syn::{parse_macro_input, AttributeArgs, DeriveInput, ItemFn};
19
20#[proc_macro_derive(Project, attributes(project))]
21pub fn derive_project(_tokens: proc_macro::TokenStream) -> proc_macro::TokenStream {
22 let tokens = &parse_macro_input!(_tokens as DeriveInput);
23 let ident = &tokens.ident;
24 let attributes = &tokens.attrs;
25 let data = &tokens.data;
26 let generics = &tokens.generics;
27 let expanded = project::impl_project(ident, attributes, data, generics);
28 proc_macro::TokenStream::from(expanded)
29}
30
31#[proc_macro_derive(Filter, attributes(filter))]
32pub fn derive_filter(_tokens: proc_macro::TokenStream) -> proc_macro::TokenStream {
33 let tokens = &parse_macro_input!(_tokens as DeriveInput);
34 let ident = &tokens.ident;
35 let attributes = &tokens.attrs;
36 let generics = &tokens.generics;
37 let expanded = filter::impl_filter(ident, attributes, generics);
38 proc_macro::TokenStream::from(expanded)
39}
40
41#[proc_macro_derive(FieldAccept, attributes(visit))]
42pub fn derive_field_accept(_tokens: proc_macro::TokenStream) -> proc_macro::TokenStream {
43 let tokens = &parse_macro_input!(_tokens as DeriveInput);
44 let ident = &tokens.ident;
45 let data = &tokens.data;
46 let generics = &tokens.generics;
47 let expanded = field::impl_field_visit(ident, data, generics);
48 proc_macro::TokenStream::from(expanded)
49}
50
51#[proc_macro_derive(HashedBy, attributes(hash))]
52pub fn derive_hashedby(_tokens: proc_macro::TokenStream) -> proc_macro::TokenStream {
53 let tokens = &parse_macro_input!(_tokens as DeriveInput);
54 let ident = &tokens.ident;
55 let data = &tokens.data;
56 let generics = &tokens.generics;
57 let expanded = hashedby::impl_hashed_by(ident, data, generics);
58 proc_macro::TokenStream::from(expanded)
59}
60
61#[proc_macro_derive(OrderedBy, attributes(order))]
62pub fn derive_orderby(_tokens: proc_macro::TokenStream) -> proc_macro::TokenStream {
63 let tokens = &parse_macro_input!(_tokens as DeriveInput);
64 let ident = &tokens.ident;
65 let data = &tokens.data;
66 let generics = &tokens.generics;
67 let expanded = orderedby::impl_ordered_by(ident, data, generics);
68 proc_macro::TokenStream::from(expanded)
69}
70
71#[proc_macro_derive(Bootstrap, attributes(pipe, cstore, error))]
72pub fn derive_bootstrap(_tokens: proc_macro::TokenStream) -> proc_macro::TokenStream {
73 let tokens = &parse_macro_input!(_tokens as DeriveInput);
74 let ident = &tokens.ident;
75 let attributes = &tokens.attrs;
76 let generics = &tokens.generics;
77 let expanded = bootstrap::impl_bootstrap(ident, attributes, generics);
78 proc_macro::TokenStream::from(expanded)
79}
80
81#[proc_macro_attribute]
82pub fn bootstrap(
83 args: proc_macro::TokenStream,
84 item: proc_macro::TokenStream,
85) -> proc_macro::TokenStream {
86 let args = parse_macro_input!(args as AttributeArgs);
87 let function = parse_macro_input!(item as ItemFn);
88 let expanded = bootstrap::impl_bootstrap_macro(args, function);
89 proc_macro::TokenStream::from(expanded)
90}
91
92#[proc_macro_attribute]
93pub fn main(
94 args: proc_macro::TokenStream,
95 item: proc_macro::TokenStream,
96) -> proc_macro::TokenStream {
97 let args = parse_macro_input!(args as AttributeArgs);
98 let function = parse_macro_input!(item as ItemFn);
99 let expanded = bootstrap::impl_bootstrap_main_macro(args, function);
100 proc_macro::TokenStream::from(expanded)
101}
102
103#[proc_macro_derive(AggregateAs, attributes(agg))]
104pub fn derive_aggregate_as(_tokens: proc_macro::TokenStream) -> proc_macro::TokenStream {
105 let tokens = &parse_macro_input!(_tokens as DeriveInput);
106 let attributes = &tokens.attrs;
107 let ident = &tokens.ident;
108 let data = &tokens.data;
109 let generics = &tokens.generics;
110 let expanded = aggregate::impl_aggregate_as(ident, attributes, data, generics);
111 proc_macro::TokenStream::from(expanded)
112}
113
114#[proc_macro_derive(GroupAs, attributes(group))]
115pub fn derive_group_as(_tokens: proc_macro::TokenStream) -> proc_macro::TokenStream {
116 let tokens = &parse_macro_input!(_tokens as DeriveInput);
117 let ident = &tokens.ident;
118 let data = &tokens.data;
119 let generics = &tokens.generics;
120 let expanded = group::impl_group_as(ident, data, generics);
121 proc_macro::TokenStream::from(expanded)
122}
123
124#[proc_macro_derive(Equal, attributes(equal))]
125pub fn derive_equal(_tokens: proc_macro::TokenStream) -> proc_macro::TokenStream {
126 let tokens = &parse_macro_input!(_tokens as DeriveInput);
127 let ident = &tokens.ident;
128 let data = &tokens.data;
129 let generics = &tokens.generics;
130 let expanded = equal::impl_equal(ident, data, generics);
131 proc_macro::TokenStream::from(expanded)
132}
133
134#[proc_macro_derive(LeftRight, attributes(left, right))]
135pub fn derive_left_right(_tokens: proc_macro::TokenStream) -> proc_macro::TokenStream {
136 let tokens = &parse_macro_input!(_tokens as DeriveInput);
137 let ident = &tokens.ident;
138 let data = &tokens.data;
139 let generics = &tokens.generics;
140 let expanded = leftright::impl_left_right(ident, data, generics);
141 proc_macro::TokenStream::from(expanded)
142}
143
144#[proc_macro_derive(Render, attributes(render))]
145pub fn derive_render(_tokens: proc_macro::TokenStream) -> proc_macro::TokenStream {
146 let tokens = &parse_macro_input!(_tokens as DeriveInput);
147 let ident = &tokens.ident;
148 let attributes = &tokens.attrs;
149 let data = &tokens.data;
150 let generics = &tokens.generics;
151 let expanded = render::impl_render(ident, attributes, data, generics);
152 proc_macro::TokenStream::from(expanded)
153}
154
155#[proc_macro_derive(Convert, attributes(convert))]
156pub fn derive_convert(_tokens: proc_macro::TokenStream) -> proc_macro::TokenStream {
157 let tokens = &parse_macro_input!(_tokens as DeriveInput);
158 let ident = &tokens.ident;
159 let attributes = &tokens.attrs;
160 let data = &tokens.data;
161 let generics = &tokens.generics;
162 let expanded = convert::impl_convert(ident, attributes, data, generics);
163 proc_macro::TokenStream::from(expanded)
164}
165
166#[proc_macro_derive(IntoAttributes, attributes(attribute))]
167pub fn derive_into_attributes(_tokens: proc_macro::TokenStream) -> proc_macro::TokenStream {
168 let tokens = &parse_macro_input!(_tokens as DeriveInput);
169 let ident = &tokens.ident;
170 let data = &tokens.data;
171 let generics = &tokens.generics;
172 let expanded = attribute::impl_into_attributes(ident, data, generics);
173 proc_macro::TokenStream::from(expanded)
174}