Improve code readability

Author: GuillaumeGomez

rinja_derive/src/generator.rs

@@ -176,8 +176,8 @@ impl<'a, 'h> Generator<'a, 'h> {
         buf.write('}');
 
         #[cfg(feature = "blocks")]
-        for (block, span) in self.input.blocks {
-            self.impl_block(buf, block, span)?;
+        for block in self.input.blocks {
+            self.impl_block(buf, block)?;
         }
 
         Ok(size_hint)
@@ -187,8 +187,7 @@ impl<'a, 'h> Generator<'a, 'h> {
     fn impl_block(
         &self,
         buf: &mut Buffer,
-        block: &str,
-        span: &proc_macro2::Span,
+        block: &crate::input::Block,
     ) -> Result<(), CompileError> {
         // RATIONALE: `*self` must be the input type, implementation details should not leak:
         // - impl Self { fn as_block(self) } ->
@@ -199,7 +198,7 @@ impl<'a, 'h> Generator<'a, 'h> {
         use quote::quote_spanned;
         use syn::{GenericParam, Ident, Lifetime, LifetimeParam, Token};
 
-        let span = *span;
+        let span = block.span;
         buf.write(
             "\
             #[allow(missing_docs, non_camel_case_types, non_snake_case, unreachable_pub)]\
@@ -208,11 +207,14 @@ impl<'a, 'h> Generator<'a, 'h> {
 
         let ident = &self.input.ast.ident;
 
-        let doc = format!("A sub-template that renders only the block `{block}` of [`{ident}`].");
-        let method_name = format!("as_{block}");
-        let trait_name = format!("__Rinja__{ident}__as__{block}");
-        let wrapper_name = format!("__Rinja__{ident}__as__{block}__Wrapper");
-        let self_lt_name = format!("'__Rinja__{ident}__as__{block}__self");
+        let doc = format!(
+            "A sub-template that renders only the block `{}` of [`{ident}`].",
+            block.name
+        );
+        let method_name = format!("as_{}", block.name);
+        let trait_name = format!("__Rinja__{ident}__as__{}", block.name);
+        let wrapper_name = format!("__Rinja__{ident}__as__{}__Wrapper", block.name);
+        let self_lt_name = format!("'__Rinja__{ident}__as__{}__self", block.name);
 
         let method_id = Ident::new(&method_name, span);
         let trait_id = Ident::new(&trait_name, span);
@@ -235,7 +237,7 @@ impl<'a, 'h> Generator<'a, 'h> {
             wrapper_generics.split_for_impl();
 
         let input = TemplateInput {
-            block: Some((block, span)),
+            block: Some((&block.name, span)),
             #[cfg(feature = "blocks")]
             blocks: &[],
             ..self.input.clone()

rinja_derive/src/input.rs

@@ -27,7 +27,7 @@ pub(crate) struct TemplateInput<'a> {
     pub(crate) source_span: Option<Span>,
     pub(crate) block: Option<(&'a str, Span)>,
     #[cfg(feature = "blocks")]
-    pub(crate) blocks: &'a [(String, Span)],
+    pub(crate) blocks: &'a [Block],
     pub(crate) print: Print,
     pub(crate) escaper: &'a str,
     pub(crate) path: Arc<Path>,
@@ -351,11 +351,17 @@ impl AnyTemplateArgs {
     }
 }
 
+#[cfg(feature = "blocks")]
+pub(crate) struct Block {
+    pub(crate) name: String,
+    pub(crate) span: Span,
+}
+
 pub(crate) struct TemplateArgs {
     pub(crate) source: (Source, Option<Span>),
     block: Option<(String, Span)>,
     #[cfg(feature = "blocks")]
-    blocks: Vec<(String, Span)>,
+    blocks: Vec<Block>,
     print: Print,
     escaping: Option<String>,
     ext: Option<String>,
@@ -410,7 +416,10 @@ impl TemplateArgs {
                 .blocks
                 .unwrap_or_default()
                 .into_iter()
-                .map(|value| (value.value(), value.span()))
+                .map(|value| Block {
+                    name: value.value(),
+                    span: value.span(),
+                })
                 .collect(),
             print: args.print.unwrap_or_default(),
             escaping: args.escape.map(|value| value.value()),