1use quote::quote;
2use syn::{parse_macro_input, DeriveInput};
3
4mod attr;
5mod codegen;
6mod condense;
7mod context;
8mod expr;
9mod template_source;
10
11use template_source::{extract_dir_attribute, resolve_template_path, TemplateSource};
12
13#[proc_macro_derive(Hemplate, attributes(hemplate))]
14pub fn derive_hemplate(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
15 let input = parse_macro_input!(input as DeriveInput);
16 let name = &input.ident;
17
18 match &input.data {
19 syn::Data::Struct(_) => {
20 let source = match template_source::load(&input.attrs, name) {
21 Ok(source) => source,
22 Err(error) => return failed(&input, error).into(),
23 };
24 gen_struct_tokens(&input, &source).into()
25 }
26 syn::Data::Enum(data_enum) => gen_enum_impl(name, data_enum, &input),
27 syn::Data::Union(_) => syn::Error::new_spanned(
28 &input.ident,
29 "Hemplate can only be derived for structs and enums",
30 )
31 .to_compile_error()
32 .into(),
33 }
34}
35
36fn failed(input: &DeriveInput, error: syn::Error) -> proc_macro2::TokenStream {
41 let name = &input.ident;
42 let (impl_generics, type_generics, where_clause) = input.generics.split_for_impl();
43 let error = error.to_compile_error();
44 quote! {
45 #error
46 impl #impl_generics ::hemplate::__runtime::Hemplate for #name #type_generics #where_clause {
47 fn render_into(&self, _: &mut dyn ::core::fmt::Write) -> Result<(), ::hemplate::__runtime::error::RenderError> {
48 ::core::unreachable!("template failed to compile")
49 }
50 }
51 }
52}
53
54fn gen_struct_tokens(input: &DeriveInput, source: &TemplateSource) -> proc_macro2::TokenStream {
55 let name = &input.ident;
56 let (impl_generics, type_generics, where_clause) = input.generics.split_for_impl();
57 let body = codegen::generate_body(
58 &source.ast,
59 &template_source::diagnostic_path(&source.path),
60 source.transform.as_ref(),
61 );
62 let template_size_hint = source.ast.content().len();
63 let tracked_dependency = template_source::tracked_dependency(&source.path);
64 let tracked_transform = template_source::tracked_transform(source.transform.as_ref());
65 let output = quote! {
66 #tracked_dependency
67 #tracked_transform
68
69 impl #impl_generics ::hemplate::__runtime::Hemplate for #name #type_generics #where_clause {
70 fn render_into(&self, buf: &mut dyn ::core::fmt::Write) -> Result<(), ::hemplate::__runtime::error::RenderError> {
71 use std::fmt::Write as _;
72 use ::hemplate::__runtime::render::EscapedFallback as _;
73 use ::hemplate::__runtime::render::PresentFallback as _;
74 use ::hemplate::__runtime::render::RawGuardFallback as _;
75 #body
76 Ok(())
77 }
78
79 fn size_hint(&self) -> usize {
80 #template_size_hint
81 }
82 }
83 };
84 output
85}
86
87fn is_delegation_variant(variant: &syn::Variant) -> bool {
90 matches!(&variant.fields, syn::Fields::Unnamed(fields) if fields.unnamed.len() == 1)
91}
92
93fn gen_enum_impl(
94 name: &syn::Ident,
95 data_enum: &syn::DataEnum,
96 input: &syn::DeriveInput,
97) -> proc_macro::TokenStream {
98 let (impl_generics, type_generics, where_clause) = input.generics.split_for_impl();
99 let enum_snake = to_snake_case(&name.to_string());
100 let enum_dir = match extract_dir_attribute(&input.attrs, &input.ident) {
101 Ok(d) => d,
102 Err(e) => return failed(input, e).into(),
103 };
104 let default_dir = if enum_dir.is_empty() {
105 enum_snake.clone()
106 } else {
107 enum_dir
108 };
109
110 let mut match_arms = Vec::new();
111 let mut size_hint_arms = Vec::new();
112 let mut template_paths = Vec::new();
113 let mut tracked_transforms = Vec::new();
114
115 for variant in &data_enum.variants {
116 let variant_ident = &variant.ident;
117
118 if is_delegation_variant(variant) {
119 match_arms.push(quote! {
123 #name::#variant_ident(_inner) => {
124 ::hemplate::__runtime::Hemplate::render_into(_inner, buf)?;
125 }
126 });
127 size_hint_arms.push(quote! {
128 #name::#variant_ident(_inner) => ::hemplate::__runtime::Hemplate::size_hint(_inner),
129 });
130 continue;
131 }
132
133 let variant_snake = to_snake_case(&variant_ident.to_string());
134 let variant_dir = match extract_dir_attribute(&variant.attrs, variant_ident) {
135 Ok(d) => d,
136 Err(e) => return failed(input, e).into(),
137 };
138 let dir = if variant_dir.is_empty() {
139 default_dir.clone()
140 } else {
141 variant_dir
142 };
143 let variant_path = match resolve_template_path(&dir, &variant_snake, variant_ident) {
144 Ok(p) => p,
145 Err(e) => return failed(input, e).into(),
146 };
147 template_paths.push(variant_path.clone());
148
149 let ast = match template_source::load_variant(&variant_path, variant_ident, &input.ident) {
150 Ok(ast) => ast,
151 Err(error) => return failed(input, error).into(),
152 };
153
154 let transform = match template_source::load_variant_transform(
155 &variant_path,
156 variant_ident,
157 &input.ident,
158 ) {
159 Ok(transform) => transform,
160 Err(error) => return failed(input, error).into(),
161 };
162 tracked_transforms.push(template_source::tracked_transform(transform.as_ref()));
163 let body = codegen::generate_body(
164 &ast,
165 &template_source::diagnostic_path(&variant_path),
166 transform.as_ref(),
167 );
168 let template_size_hint = ast.content().len();
169
170 let (arm, size_hint_arm) = match &variant.fields {
171 syn::Fields::Named(fields) => {
172 let field_names: Vec<_> = fields.named.iter().map(|f| &f.ident).collect();
173 (
174 quote! {
175 #name::#variant_ident { #(#field_names),* } => {
176 #body
177 }
178 },
179 quote! {
180 #name::#variant_ident { .. } => #template_size_hint,
181 },
182 )
183 }
184 syn::Fields::Unnamed(fields) => {
185 let field_bindings: Vec<syn::Ident> = (0..fields.unnamed.len())
186 .map(|i| syn::Ident::new(&format!("_{i}"), variant_ident.span()))
187 .collect();
188 (
189 quote! {
190 #name::#variant_ident(#(#field_bindings),*) => {
191 #body
192 }
193 },
194 quote! {
195 #name::#variant_ident(..) => #template_size_hint,
196 },
197 )
198 }
199 syn::Fields::Unit => (
200 quote! {
201 #name::#variant_ident => {
202 #body
203 }
204 },
205 quote! {
206 #name::#variant_ident => #template_size_hint,
207 },
208 ),
209 };
210 match_arms.push(arm);
211 size_hint_arms.push(size_hint_arm);
212 }
213
214 let tracked_dependencies = template_source::tracked_dependencies(&template_paths);
215
216 let output = quote! {
217 #tracked_dependencies
218 #(#tracked_transforms)*
219
220 impl #impl_generics ::hemplate::__runtime::Hemplate for #name #type_generics #where_clause {
221 fn render_into(&self, buf: &mut dyn ::core::fmt::Write) -> Result<(), ::hemplate::__runtime::error::RenderError> {
222 use std::fmt::Write as _;
223 use ::hemplate::__runtime::render::EscapedFallback as _;
224 use ::hemplate::__runtime::render::PresentFallback as _;
225 use ::hemplate::__runtime::render::RawGuardFallback as _;
226 match self {
227 #(#match_arms)*
228 }
229 Ok(())
230 }
231
232 fn size_hint(&self) -> usize {
233 match self {
234 #(#size_hint_arms)*
235 }
236 }
237 }
238 };
239 output.into()
240}
241
242fn to_snake_case(s: &str) -> String {
243 let mut result = String::new();
244 for (i, c) in s.chars().enumerate() {
245 if c.is_uppercase() {
246 if i > 0 {
247 result.push('_');
248 }
249 result.extend(c.to_lowercase());
250 } else {
251 result.push(c);
252 }
253 }
254 result
255}
256
257#[cfg(test)]
258mod tests {
259 use super::*;
260
261 #[test]
262 fn generated_struct_implements_hemplate_without_display() {
263 let ast = hemplate_core::ast::build_ast(std::sync::Arc::new("<p>probe</p>".into()))
264 .unwrap()
265 .unwrap();
266 let input = syn::parse_quote!(
267 struct Probe;
268 );
269 let source = TemplateSource {
270 path: "probe.heml".into(),
271 ast,
272 transform: None,
273 };
274 let output = gen_struct_tokens(&input, &source).to_string();
275
276 assert!(output.contains("impl :: hemplate :: __runtime :: Hemplate for Probe"));
277 assert!(!output.contains("Display for Probe"));
278 }
279
280 #[test]
281 fn to_snake_case_basic() {
282 assert_eq!(to_snake_case("HomePage"), "home_page");
283 assert_eq!(to_snake_case("NavBar"), "nav_bar");
284 assert_eq!(to_snake_case("A"), "a");
285 assert_eq!(to_snake_case("already_snake"), "already_snake");
286 }
287}