From 26f598c0d189769952b11ea9fe6168718f403590 Mon Sep 17 00:00:00 2001
From: René Kijewski <rene.kijewski@fu-berlin.de>
Date: Tue, 1 Aug 2023 03:38:56 +0200
Subject: parser: add type for `Node::BlockDef`
---
askama_derive/src/generator.rs | 20 ++++++--------------
askama_derive/src/heritage.rs | 27 +++++++--------------------
2 files changed, 13 insertions(+), 34 deletions(-)
(limited to 'askama_derive')
diff --git a/askama_derive/src/generator.rs b/askama_derive/src/generator.rs
index 60ffa27..beb3c49 100644
--- a/askama_derive/src/generator.rs
+++ b/askama_derive/src/generator.rs
@@ -650,8 +650,8 @@ impl<'a> Generator<'a> {
Node::Loop(ref loop_block) => {
size_hint += self.write_loop(ctx, buf, loop_block)?;
}
- Node::BlockDef(ws1, name, _, ws2) => {
- size_hint += self.write_block(buf, Some(name), Ws(ws1.0, ws2.1))?;
+ Node::BlockDef(ref b) => {
+ size_hint += self.write_block(buf, Some(b.name), Ws(b.ws1.0, b.ws2.1))?;
}
Node::Include(ws, path) => {
size_hint += self.handle_include(ctx, buf, ws, path)?;
@@ -1163,26 +1163,18 @@ impl<'a> Generator<'a> {
// Get the block definition from the heritage chain
let heritage = self
.heritage
- .as_ref()
.ok_or_else(|| CompileError::from("no block ancestors available"))?;
- let (ctx, def) = heritage.blocks[cur.0].get(cur.1).ok_or_else(|| {
+ let (ctx, def) = *heritage.blocks[cur.0].get(cur.1).ok_or_else(|| {
CompileError::from(match name {
None => format!("no super() block found for block '{}'", cur.0),
Some(name) => format!("no block found for name '{name}'"),
})
})?;
- // Get the nodes and whitespace suppression data from the block definition
- let (ws1, nodes, ws2) = if let Node::BlockDef(ws1, _, nodes, ws2) = def {
- (ws1, nodes, ws2)
- } else {
- unreachable!()
- };
-
// Handle inner whitespace suppression spec and process block nodes
- self.prepare_ws(*ws1);
+ self.prepare_ws(def.ws1);
self.locals.push();
- let size_hint = self.handle(ctx, nodes, buf, AstLevel::Block)?;
+ let size_hint = self.handle(ctx, &def.nodes, buf, AstLevel::Block)?;
if !self.locals.is_current_empty() {
// Need to flush the buffer before popping the variable stack
@@ -1190,7 +1182,7 @@ impl<'a> Generator<'a> {
}
self.locals.pop();
- self.flush_ws(*ws2);
+ self.flush_ws(def.ws2);
// Restore original block context and set whitespace suppression for
// succeeding whitespace according to the outer WS spec
diff --git a/askama_derive/src/heritage.rs b/askama_derive/src/heritage.rs
index fbbb71f..2a7ef43 100644
--- a/askama_derive/src/heritage.rs
+++ b/askama_derive/src/heritage.rs
@@ -3,7 +3,7 @@ use std::path::{Path, PathBuf};
use crate::config::Config;
use crate::CompileError;
-use parser::{Loop, Macro, Match, Node};
+use parser::{BlockDef, Loop, Macro, Match, Node};
pub(crate) struct Heritage<'a> {
pub(crate) root: &'a Context<'a>,
@@ -32,12 +32,12 @@ impl Heritage<'_> {
}
}
-type BlockAncestry<'a> = HashMap<&'a str, Vec<(&'a Context<'a>, &'a Node<'a>)>>;
+type BlockAncestry<'a> = HashMap<&'a str, Vec<(&'a Context<'a>, &'a BlockDef<'a>)>>;
pub(crate) struct Context<'a> {
pub(crate) nodes: &'a [Node<'a>],
pub(crate) extends: Option<PathBuf>,
- pub(crate) blocks: HashMap<&'a str, &'a Node<'a>>,
+ pub(crate) blocks: HashMap<&'a str, &'a BlockDef<'a>>,
pub(crate) macros: HashMap<&'a str, &'a Macro<'a>>,
pub(crate) imports: HashMap<&'a str, PathBuf>,
}
@@ -49,7 +49,7 @@ impl Context<'_> {
nodes: &'n [Node<'n>],
) -> Result<Context<'n>, CompileError> {
let mut extends = None;
- let mut blocks = Vec::new();
+ let mut blocks = HashMap::new();
let mut macros = HashMap::new();
let mut imports = HashMap::new();
let mut nested = vec![nodes];
@@ -76,11 +76,9 @@ impl Context<'_> {
"extends, macro or import blocks not allowed below top level".into(),
);
}
- def @ Node::BlockDef(_, _, _, _) => {
- blocks.push(def);
- if let Node::BlockDef(_, _, nodes, _) = def {
- nested.push(nodes);
- }
+ Node::BlockDef(b) => {
+ blocks.insert(b.name, b);
+ nested.push(&b.nodes);
}
Node::Cond(branches, _) => {
for cond in branches {
@@ -106,17 +104,6 @@ impl Context<'_> {
top = false;
}
- let blocks: HashMap<_, _> = blocks
- .iter()
- .map(|def| {
- if let Node::BlockDef(_, name, _, _) = def {
- (*name, *def)
- } else {
- unreachable!()
- }
- })
- .collect();
-
Ok(Context {
nodes,
extends,
--
cgit