Skip to main content

hemplate_derive/
lib.rs

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
36/// Report a template that cannot be compiled once, at its source.
37///
38/// The placeholder implementation keeps callers such as `.render()` type
39/// checking, so rustc shows only the template diagnostic, not follow-on errors.
40fn 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
87/// Returns `true` if the variant is a newtype (single unnamed field) that
88/// should delegate to its inner type's `Hemplate::render_into`.
89fn 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            // Newtype variant: delegate to inner type's Hemplate impl.
120            // If the inner type doesn't implement Hemplate, rustc will
121            // produce a clear type error at the call site.
122            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}