DynTemplate and lifetime generic in Template structs.

[useche]

Hi!

I need to create a hierarchy of structures that I can render. My thought was that I could use DynTemplate to do things like this:

#[derive(Template)]
#[template(source = "{% for e in self.0 %} {{e}} {% endfor %}", ext = "none")]
pub struct List<'a>(Vec<Box<dyn DynTemplate + 'a>>);

However, this gives me the following error.

error[E0521]: borrowed data escapes outside of method
 --> src/lib.rs:3:10
  |
3 | #[derive(Template)]
  |          ^^^^^^^^
  |          |
  |          `self` is a reference that is only valid in the method body
  |          `self` escapes the method body here
  |          lifetime `'a` defined here
  |          argument requires that `'a` must outlive `'static`
  |
  = note: this error originates in the derive macro `Template` (in Nightly builds, run with -Z macro-backtrace for more info)

It has to do with the lifetime 'a that I'm adding there. I need that lifetime because my structures are using references and need to explicitly specify the lifetime. When I expand the macro, this is what it is generated:

#![feature(prelude_import)]
#[prelude_import]
use std::prelude::rust_2024::*;
#[macro_use]
extern crate std;
use askama::{DynTemplate, Template};
#[template(
    source = "{% for e in self.0 %} {{e}} {% endfor %}",
    ext = "none",
    print = "all"
)]
pub struct List<'a>(Vec<Box<dyn DynTemplate + 'a>>);
const _: () = {
    extern crate askama;
    impl<'a> askama::Template for List<'a> {
        fn render_into_with_values<AskamaW>(
            &self,
            __askama_writer: &mut AskamaW,
            __askama_values: &dyn askama::Values,
        ) -> askama::Result<()>
        where
            AskamaW: askama::helpers::core::fmt::Write
                + ?askama::helpers::core::marker::Sized,
        {
            #[allow(unused_imports)]
            use askama::{
                filters::{AutoEscape as _, WriteWritable as _},
                helpers::{ResultConverter as _, core::fmt::Write as _},
            };
            {
                let _iter = (&self.0).into_iter();
                for (e, _loop_item) in askama::helpers::TemplateLoop::new(_iter) {
                    __askama_writer.write_str(" ")?;
                    match (
                        &((&&askama::filters::AutoEscaper::new(
                            &(e),
                            askama::filters::Text,
                        ))
                            .askama_auto_escape()?),
                    ) {
                        (expr1,) => {
                            (&&&askama::filters::Writable(expr1))
                                .askama_write(__askama_writer, __askama_values)?;
                        }
                    }
                    __askama_writer.write_str(" ")?;
                }
            }
            askama::Result::Ok(())
        }
        const SIZE_HINT: askama::helpers::core::primitive::usize = 7usize;
    }
    /// Implement the [`format!()`][askama::helpers::std::format] trait for [`List`]
    ///
    /// Please be aware of the rendering performance notice in the [`Template`][askama::Template] trait.
    impl<'a> askama::helpers::core::fmt::Display for List<'a> {
        #[inline]
        fn fmt(
            &self,
            f: &mut askama::helpers::core::fmt::Formatter<'_>,
        ) -> askama::helpers::core::fmt::Result {
            askama::Template::render_into(self, f)
                .map_err(|_| askama::helpers::core::fmt::Error)
        }
    }
    impl<'a> askama::FastWritable for List<'a> {
        #[inline]
        fn write_into<AskamaW>(
            &self,
            dest: &mut AskamaW,
            values: &dyn askama::Values,
        ) -> askama::Result<()>
        where
            AskamaW: askama::helpers::core::fmt::Write
                + ?askama::helpers::core::marker::Sized,
        {
            askama::Template::render_into_with_values(self, dest, values)
        }
    }
};
impl<'a> List<'a> {
    pub fn from(list: Vec<Box<dyn DynTemplate + 'a>>) -> Self {
        Self(list)
    }
}

When I try to compile that, I get this error:

error[E0521]: borrowed data escapes outside of method
  --> src/lib.rs:35:27
   |
15 |       impl<'a> askama::Template for List<'a> {
   |            -- lifetime `'a` defined here
16 |           fn render_into_with_values<AskamaW>(
17 |               &self,
   |               ----- `self` is a reference that is only valid in the method body
...
35 |                           &((&&askama::filters::AutoEscaper::new(
   |  ___________________________^
36 | |                             &(e),
37 | |                             askama::filters::Text,
38 | |                         ))
39 | |                             .askama_auto_escape()?),
   | |                                                 ^
   | |                                                 |
   | |_________________________________________________`self` escapes the method body here
   |                                                   argument requires that `'a` must outlive `'static`

So it seems like it has to do with the implementation of render_into_with_values. But I don't understand the error and much less how to fix it. Why is self escaping the method?

[GuillaumeGomez]

Interesting case. Didn't look into it yet but maybe @Kijewski already has some ideas? :)