itsscb/askama
1
0
Fork 0
mirror of https://github.com/askama-rs/askama.git synced 2025-09-30 22:41:13 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fix locals handling

Browse Source
This commit is contained in:
Guillaume Gomez 2024-08-21 23:03:06 +02:00
parent 5e933d0152
commit 5a1d6c1601
1 changed files with 289 additions and 271 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

192
rinja_derive/src/generator.rs
View File

@ -104,6 +104,16 @@ impl<'a> Generator<'a> {
Ok(buf.buf) Ok(buf.buf)
} }
fn push_locals<T, F: FnOnce(&mut Self) -> Result<T, CompileError>>(
&mut self,
callback: F,
) -> Result<T, CompileError> {
self.locals.scopes.push(HashMap::default());
let res = callback(self);
self.locals.scopes.pop().unwrap();
res
}
// Implement `Template` for the given context struct. // Implement `Template` for the given context struct.
fn impl_template(&mut self, ctx: &Context<'a>, buf: &mut Buffer) -> Result<(), CompileError> { fn impl_template(&mut self, ctx: &Context<'a>, buf: &mut Buffer) -> Result<(), CompileError> {
self.write_header(buf, format_args!("{CRATE}::Template"), None); self.write_header(buf, format_args!("{CRATE}::Template"), None);
@ -558,16 +568,16 @@ impl<'a> Generator<'a> {
self.handle_ws(ws_before); self.handle_ws(ws_before);
} }
for (pos, cond_info) in conds.conds.iter().enumerate() { let mut iter = conds.conds.iter().enumerate().peekable();
while let Some((pos, cond_info)) = iter.next() {
let cond = cond_info.cond; let cond = cond_info.cond;
if pos == 0 {
self.handle_ws(cond.ws); self.handle_ws(cond.ws);
flushed += self.write_buf_writable(ctx, buf)?; flushed += self.write_buf_writable(ctx, buf)?;
if pos > 0 {
self.locals.pop();
} }
self.locals.push(); self.push_locals(|this| {
let mut arm_size = 0; let mut arm_size = 0;
if let Some(CondTest { target, expr, .. }) = &cond.cond { if let Some(CondTest { target, expr, .. }) = &cond.cond {
@ -594,14 +604,14 @@ impl<'a> Generator<'a> {
// but this one should have access to the let-bound variable. // but this one should have access to the let-bound variable.
match &**expr { match &**expr {
Expr::BinOp(op, ref left, ref right) if *op == "||" || *op == "&&" => { Expr::BinOp(op, ref left, ref right) if *op == "||" || *op == "&&" => {
self.visit_expr(ctx, &mut expr_buf, left)?; this.visit_expr(ctx, &mut expr_buf, left)?;
self.visit_target(buf, true, true, target); this.visit_target(buf, true, true, target);
expr_buf.write(format_args!(" {op} ")); expr_buf.write(format_args!(" {op} "));
self.visit_expr(ctx, &mut expr_buf, right)?; this.visit_expr(ctx, &mut expr_buf, right)?;
} }
_ => { _ => {
self.visit_expr(ctx, &mut expr_buf, expr)?; this.visit_expr(ctx, &mut expr_buf, expr)?;
self.visit_target(buf, true, true, target); this.visit_target(buf, true, true, target);
} }
} }
buf.write(format_args!("= &{} {{", expr_buf.buf)); buf.write(format_args!("= &{} {{", expr_buf.buf));
@ -612,7 +622,7 @@ impl<'a> Generator<'a> {
// coerces e.g. `&&&bool` to `&bool`. Then `*(&bool)` // coerces e.g. `&&&bool` to `&bool`. Then `*(&bool)`
// finally dereferences it to `bool`. // finally dereferences it to `bool`.
buf.write("*(&("); buf.write("*(&(");
buf.write(self.visit_expr_root(ctx, expr)?); buf.write(this.visit_expr_root(ctx, expr)?);
buf.write(") as &::core::primitive::bool) {"); buf.write(") as &::core::primitive::bool) {");
} }
} else if pos != 0 { } else if pos != 0 {
@ -621,22 +631,29 @@ impl<'a> Generator<'a> {
} }
if cond_info.generate_content { if cond_info.generate_content {
arm_size += self.handle(ctx, &cond.nodes, buf, AstLevel::Nested)?; arm_size += this.handle(ctx, &cond.nodes, buf, AstLevel::Nested)?;
} }
arm_sizes.push(arm_size); arm_sizes.push(arm_size);
if let Some((_, cond_info)) = iter.peek() {
let cond = cond_info.cond;
this.handle_ws(cond.ws);
flushed += this.write_buf_writable(ctx, buf)?;
} else {
if let Some(ws_after) = conds.ws_after {
this.handle_ws(ws_after);
}
this.handle_ws(if_.ws);
flushed += this.write_buf_writable(ctx, buf)?;
}
Ok(0)
})?;
} }
if let Some(ws_after) = conds.ws_after {
self.handle_ws(ws_after);
}
self.handle_ws(if_.ws);
flushed += self.write_buf_writable(ctx, buf)?;
if conds.nb_conds > 0 { if conds.nb_conds > 0 {
buf.write('}'); buf.write('}');
} }
if !conds.conds.is_empty() {
self.locals.pop();
}
if !has_else && !conds.conds.is_empty() { if !has_else && !conds.conds.is_empty() {
arm_sizes.push(0); arm_sizes.push(0);
@ -666,32 +683,36 @@ impl<'a> Generator<'a> {
buf.write(format_args!("match &{expr_code} {{")); buf.write(format_args!("match &{expr_code} {{"));
let mut arm_size = 0; let mut arm_size = 0;
for (i, arm) in arms.iter().enumerate() { let mut iter = arms.iter().enumerate().peekable();
while let Some((i, arm)) = iter.next() {
if i == 0 {
self.handle_ws(arm.ws); self.handle_ws(arm.ws);
if i > 0 {
arm_sizes.push(arm_size + self.write_buf_writable(ctx, buf)?);
buf.write('}');
self.locals.pop();
} }
self.locals.push(); self.push_locals(|this| {
for (index, target) in arm.target.iter().enumerate() { for (index, target) in arm.target.iter().enumerate() {
if index != 0 { if index != 0 {
buf.write('|'); buf.write('|');
} }
self.visit_target(buf, true, true, target); this.visit_target(buf, true, true, target);
} }
buf.write(" => {"); buf.write(" => {");
arm_size = self.handle(ctx, &arm.nodes, buf, AstLevel::Nested)?; arm_size = this.handle(ctx, &arm.nodes, buf, AstLevel::Nested)?;
}
if let Some((_, arm)) = iter.peek() {
this.handle_ws(arm.ws);
arm_sizes.push(arm_size + this.write_buf_writable(ctx, buf)?);
self.handle_ws(ws2);
arm_sizes.push(arm_size + self.write_buf_writable(ctx, buf)?);
buf.write('}'); buf.write('}');
self.locals.pop(); } else {
this.handle_ws(ws2);
arm_sizes.push(arm_size + this.write_buf_writable(ctx, buf)?);
buf.write('}');
}
Ok(0)
})?;
}
buf.write('}'); buf.write('}');
@ -706,13 +727,12 @@ impl<'a> Generator<'a> {
loop_block: &'a WithSpan<'_, Loop<'_>>, loop_block: &'a WithSpan<'_, Loop<'_>>,
) -> Result<usize, CompileError> { ) -> Result<usize, CompileError> {
self.handle_ws(loop_block.ws1); self.handle_ws(loop_block.ws1);
self.locals.push(); self.push_locals(|this| {
let expr_code = this.visit_expr_root(ctx, &loop_block.iter)?;
let expr_code = self.visit_expr_root(ctx, &loop_block.iter)?;
let has_else_nodes = !loop_block.else_nodes.is_empty(); let has_else_nodes = !loop_block.else_nodes.is_empty();
let flushed = self.write_buf_writable(ctx, buf)?; let flushed = this.write_buf_writable(ctx, buf)?;
buf.write('{'); buf.write('{');
if has_else_nodes { if has_else_nodes {
buf.write("let mut _did_loop = false;"); buf.write("let mut _did_loop = false;");
@ -733,23 +753,26 @@ impl<'a> Generator<'a> {
} }
// If accessing a field then it most likely needs to be // If accessing a field then it most likely needs to be
// borrowed, to prevent an attempt of moving. // borrowed, to prevent an attempt of moving.
Expr::Attr(..) => buf.write(format_args!("let _iter = (&{expr_code}).into_iter();")), Expr::Attr(..) => {
buf.write(format_args!("let _iter = (&{expr_code}).into_iter();"))
}
// Otherwise, we borrow `iter` assuming that it implements `IntoIterator`. // Otherwise, we borrow `iter` assuming that it implements `IntoIterator`.
_ => buf.write(format_args!("let _iter = ({expr_code}).into_iter();")), _ => buf.write(format_args!("let _iter = ({expr_code}).into_iter();")),
} }
if let Some(cond) = &loop_block.cond { if let Some(cond) = &loop_block.cond {
self.locals.push(); this.push_locals(|this| {
buf.write("let _iter = _iter.filter(|"); buf.write("let _iter = _iter.filter(|");
self.visit_target(buf, true, true, &loop_block.var); this.visit_target(buf, true, true, &loop_block.var);
buf.write("| -> bool {"); buf.write("| -> bool {");
self.visit_expr(ctx, buf, cond)?; this.visit_expr(ctx, buf, cond)?;
buf.write("});"); buf.write("});");
self.locals.pop(); Ok(0)
})?;
} }
self.locals.push(); let size_hint1 = this.push_locals(|this| {
buf.write("for ("); buf.write("for (");
self.visit_target(buf, true, true, &loop_block.var); this.visit_target(buf, true, true, &loop_block.var);
buf.write(", _loop_item) in "); buf.write(", _loop_item) in ");
buf.write(CRATE); buf.write(CRATE);
buf.write("::helpers::TemplateLoop::new(_iter) {"); buf.write("::helpers::TemplateLoop::new(_iter) {");
@ -757,30 +780,32 @@ impl<'a> Generator<'a> {
if has_else_nodes { if has_else_nodes {
buf.write("_did_loop = true;"); buf.write("_did_loop = true;");
} }
let mut size_hint1 = self.handle(ctx, &loop_block.body, buf, AstLevel::Nested)?; let mut size_hint1 = this.handle(ctx, &loop_block.body, buf, AstLevel::Nested)?;
self.handle_ws(loop_block.ws2); this.handle_ws(loop_block.ws2);
size_hint1 += self.write_buf_writable(ctx, buf)?; size_hint1 += this.write_buf_writable(ctx, buf)?;
self.locals.pop(); Ok(size_hint1)
})?;
buf.write('}'); buf.write('}');
let mut size_hint2; let size_hint2;
if has_else_nodes { if has_else_nodes {
buf.write("if !_did_loop {"); buf.write("if !_did_loop {");
self.locals.push(); size_hint2 = this.push_locals(|this| {
size_hint2 = self.handle(ctx, &loop_block.else_nodes, buf, AstLevel::Nested)?; let mut size_hint =
self.handle_ws(loop_block.ws3); this.handle(ctx, &loop_block.else_nodes, buf, AstLevel::Nested)?;
size_hint2 += self.write_buf_writable(ctx, buf)?; this.handle_ws(loop_block.ws3);
self.locals.pop(); size_hint += this.write_buf_writable(ctx, buf)?;
Ok(size_hint)
})?;
buf.write('}'); buf.write('}');
} else { } else {
self.handle_ws(loop_block.ws3); this.handle_ws(loop_block.ws3);
size_hint2 = self.write_buf_writable(ctx, buf)?; size_hint2 = this.write_buf_writable(ctx, buf)?;
} }
buf.write('}'); buf.write('}');
self.locals.pop();
Ok(flushed + ((size_hint1 * 3) + size_hint2) / 2) Ok(flushed + ((size_hint1 * 3) + size_hint2) / 2)
})
} }
fn write_call( fn write_call(
@ -821,10 +846,10 @@ impl<'a> Generator<'a> {
}; };
self.flush_ws(ws); // Cannot handle_ws() here: whitespace from macro definition comes first self.flush_ws(ws); // Cannot handle_ws() here: whitespace from macro definition comes first
self.locals.push(); let size_hint = self.push_locals(|this| {
self.write_buf_writable(ctx, buf)?; this.write_buf_writable(ctx, buf)?;
buf.write('{'); buf.write('{');
self.prepare_ws(def.ws1); this.prepare_ws(def.ws1);
let mut names = Buffer::new(); let mut names = Buffer::new();
let mut values = Buffer::new(); let mut values = Buffer::new();
@ -893,16 +918,16 @@ impl<'a> Generator<'a> {
// don't reintroduce a new variable. This is // don't reintroduce a new variable. This is
// to avoid moving non-copyable values. // to avoid moving non-copyable values.
Expr::Var(name) if *name != "self" => { Expr::Var(name) if *name != "self" => {
let var = self.locals.resolve_or_self(name); let var = this.locals.resolve_or_self(name);
self.locals this.locals
.insert(Cow::Borrowed(arg), LocalMeta::with_ref(var)); .insert(Cow::Borrowed(arg), LocalMeta::with_ref(var));
} }
Expr::Attr(obj, attr) => { Expr::Attr(obj, attr) => {
let mut attr_buf = Buffer::new(); let mut attr_buf = Buffer::new();
self.visit_attr(ctx, &mut attr_buf, obj, attr)?; this.visit_attr(ctx, &mut attr_buf, obj, attr)?;
let var = self.locals.resolve(&attr_buf.buf).unwrap_or(attr_buf.buf); let var = this.locals.resolve(&attr_buf.buf).unwrap_or(attr_buf.buf);
self.locals this.locals
.insert(Cow::Borrowed(arg), LocalMeta::with_ref(var)); .insert(Cow::Borrowed(arg), LocalMeta::with_ref(var));
} }
// Everything else still needs to become variables, // Everything else still needs to become variables,
@ -922,9 +947,9 @@ impl<'a> Generator<'a> {
if !is_copyable(expr) { if !is_copyable(expr) {
values.write('&'); values.write('&');
} }
values.write(self.visit_expr_root(ctx, expr)?); values.write(this.visit_expr_root(ctx, expr)?);
values.write(')'); values.write(')');
self.locals.insert_with_default(Cow::Borrowed(arg)); this.locals.insert_with_default(Cow::Borrowed(arg));
} }
} }
} }
@ -934,12 +959,13 @@ impl<'a> Generator<'a> {
buf.write(format_args!("let ({}) = ({});", names.buf, values.buf)); buf.write(format_args!("let ({}) = ({});", names.buf, values.buf));
} }
let mut size_hint = self.handle(own_ctx, &def.nodes, buf, AstLevel::Nested)?; let mut size_hint = this.handle(own_ctx, &def.nodes, buf, AstLevel::Nested)?;
self.flush_ws(def.ws2); this.flush_ws(def.ws2);
size_hint += self.write_buf_writable(ctx, buf)?; size_hint += this.write_buf_writable(ctx, buf)?;
buf.write('}'); buf.write('}');
self.locals.pop(); Ok(size_hint)
})?;
self.prepare_ws(ws); self.prepare_ws(ws);
Ok(size_hint) Ok(size_hint)
} }
@ -961,12 +987,13 @@ impl<'a> Generator<'a> {
"let {FILTER_SOURCE} = {CRATE}::helpers::FmtCell::new(\ "let {FILTER_SOURCE} = {CRATE}::helpers::FmtCell::new(\
|writer: &mut ::core::fmt::Formatter<'_>| -> {CRATE}::Result<()> {{" |writer: &mut ::core::fmt::Formatter<'_>| -> {CRATE}::Result<()> {{"
)); ));
self.locals.push(); let size_hint = self.push_locals(|this| {
self.prepare_ws(filter.ws1); this.prepare_ws(filter.ws1);
let size_hint = self.handle(ctx, &filter.nodes, buf, AstLevel::Nested)?; let size_hint = this.handle(ctx, &filter.nodes, buf, AstLevel::Nested)?;
self.flush_ws(filter.ws2); this.flush_ws(filter.ws2);
self.write_buf_writable(ctx, buf)?; this.write_buf_writable(ctx, buf)?;
self.locals.pop(); Ok(size_hint)
})?;
buf.write(format_args!("{CRATE}::Result::Ok(())")); buf.write(format_args!("{CRATE}::Result::Ok(())"));
buf.write("});"); buf.write("});");
@ -2635,15 +2662,6 @@ where
{ {
self.insert(key, V::default()); self.insert(key, V::default());
} }
fn push(&mut self) {
self.scopes.push(HashMap::default());
}
fn pop(&mut self) {
self.scopes.pop().unwrap();
assert!(!self.scopes.is_empty());
}
} }
impl MapChain<'_, Cow<'_, str>, LocalMeta> { impl MapChain<'_, Cow<'_, str>, LocalMeta> {