aboutsummaryrefslogtreecommitdiffstats
path: root/askama_derive/src
diff options
context:
space:
mode:
Diffstat (limited to 'askama_derive/src')
-rw-r--r--askama_derive/src/generator.rs80
-rw-r--r--askama_derive/src/parser.rs2
2 files changed, 41 insertions, 41 deletions
diff --git a/askama_derive/src/generator.rs b/askama_derive/src/generator.rs
index 7547475..884ab3e 100644
--- a/askama_derive/src/generator.rs
+++ b/askama_derive/src/generator.rs
@@ -94,7 +94,7 @@ impl<'a> Generator<'a> {
::askama::Result<()> {",
);
self.handle(ctx, &ctx.nodes, AstLevel::Top);
- self.flush_ws(&WS(false, false));
+ self.flush_ws(WS(false, false));
self.writeln("Ok(())");
self.writeln("}");
self.writeln("}");
@@ -137,7 +137,7 @@ impl<'a> Generator<'a> {
if let Some(nodes) = nodes {
self.impl_blocks = true;
self.handle(ctx, nodes, AstLevel::Top);
- self.flush_ws(&WS(false, false));
+ self.flush_ws(WS(false, false));
self.impl_blocks = false;
self.writeln("Ok(())");
} else {
@@ -145,7 +145,7 @@ impl<'a> Generator<'a> {
}
self.writeln("}");
- self.flush_ws(&WS(false, false));
+ self.flush_ws(WS(false, false));
self.writeln("}");
}
@@ -248,28 +248,28 @@ impl<'a> Generator<'a> {
Node::Lit(lws, val, rws) => {
self.write_lit(lws, val, rws);
}
- Node::Comment(ref ws) => {
+ Node::Comment(ws) => {
self.write_comment(ws);
}
- Node::Expr(ref ws, ref val) => {
+ Node::Expr(ws, ref val) => {
self.write_expr(ws, val);
}
- Node::LetDecl(ref ws, ref var) => {
+ Node::LetDecl(ws, ref var) => {
self.write_let_decl(ws, var);
}
- Node::Let(ref ws, ref var, ref val) => {
+ Node::Let(ws, ref var, ref val) => {
self.write_let(ws, var, val);
}
- Node::Cond(ref conds, ref ws) => {
+ Node::Cond(ref conds, ws) => {
self.write_cond(ctx, conds, ws);
}
- Node::Match(ref ws1, ref expr, inter, ref arms, ref ws2) => {
+ Node::Match(ws1, ref expr, inter, ref arms, ws2) => {
self.write_match(ctx, ws1, expr, inter, arms, ws2);
}
- Node::Loop(ref ws1, ref var, ref iter, ref body, ref ws2) => {
+ Node::Loop(ws1, ref var, ref iter, ref body, ws2) => {
self.write_loop(ctx, ws1, var, iter, body, ws2);
}
- Node::BlockDef(ref ws1, name, _, ref ws2) => {
+ Node::BlockDef(ws1, name, _, ws2) => {
if let AstLevel::Nested = level {
panic!(
"blocks ('{}') are only allowed at the top level of a template \
@@ -279,20 +279,20 @@ impl<'a> Generator<'a> {
}
self.write_block(ws1, name, ws2);
}
- Node::Include(ref ws, path) => {
+ Node::Include(ws, path) => {
self.handle_include(ctx, ws, path);
}
- Node::Call(ref ws, scope, name, ref args) => {
+ Node::Call(ws, scope, name, ref args) => {
self.write_call(ctx, ws, scope, name, args);
}
Node::Macro(_, ref m) => {
if level != AstLevel::Top {
panic!("macro blocks only allowed at the top level");
}
- self.flush_ws(&m.ws1);
- self.prepare_ws(&m.ws2);
+ self.flush_ws(m.ws1);
+ self.prepare_ws(m.ws2);
}
- Node::Import(ref ws, _, _) => {
+ Node::Import(ws, _, _) => {
if level != AstLevel::Top {
panic!("import blocks only allowed at the top level");
}
@@ -310,21 +310,21 @@ impl<'a> Generator<'a> {
}
fn write_block_defs(&mut self, ctx: &'a Context) {
- for b in ctx.blocks.iter() {
- if let Node::BlockDef(ref ws1, name, ref nodes, ref ws2) = *b {
+ for b in &ctx.blocks {
+ if let Node::BlockDef(ws1, name, nodes, ws2) = b {
self.writeln("#[allow(unused_variables)]");
self.writeln(&format!(
"fn render_block_{}_into(&self, writer: &mut ::std::fmt::Write) \
-> ::askama::Result<()> {{",
name
));
- self.prepare_ws(ws1);
+ self.prepare_ws(*ws1);
self.locals.push();
self.handle(ctx, nodes, AstLevel::Block);
self.locals.pop();
- self.flush_ws(ws2);
+ self.flush_ws(*ws2);
self.writeln("Ok(())");
self.writeln("}");
} else {
@@ -333,8 +333,8 @@ impl<'a> Generator<'a> {
}
}
- fn write_cond(&mut self, ctx: &'a Context, conds: &'a [Cond], ws: &WS) {
- for (i, &(ref cws, ref cond, ref nodes)) in conds.iter().enumerate() {
+ fn write_cond(&mut self, ctx: &'a Context, conds: &'a [Cond], ws: WS) {
+ for (i, &(cws, ref cond, ref nodes)) in conds.iter().enumerate() {
self.handle_ws(cws);
match *cond {
Some(ref expr) => {
@@ -364,11 +364,11 @@ impl<'a> Generator<'a> {
fn write_match(
&mut self,
ctx: &'a Context,
- ws1: &WS,
+ ws1: WS,
expr: &Expr,
inter: Option<&'a str>,
arms: &'a [When],
- ws2: &WS,
+ ws2: WS,
) {
self.flush_ws(ws1);
if let Some(inter) = inter {
@@ -380,7 +380,7 @@ impl<'a> Generator<'a> {
let expr_code = self.visit_expr_root(expr);
self.writeln(&format!("match &{} {{", expr_code));
for arm in arms {
- let &(ref ws, ref variant, ref params, ref body) = arm;
+ let &(ws, ref variant, ref params, ref body) = arm;
self.locals.push();
match *variant {
Some(ref param) => {
@@ -415,11 +415,11 @@ impl<'a> Generator<'a> {
fn write_loop(
&mut self,
ctx: &'a Context,
- ws1: &WS,
+ ws1: WS,
var: &'a Target,
iter: &Expr,
body: &'a [Node],
- ws2: &WS,
+ ws2: WS,
) {
self.handle_ws(ws1);
self.locals.push();
@@ -442,7 +442,7 @@ impl<'a> Generator<'a> {
fn write_call(
&mut self,
ctx: &'a Context,
- ws: &WS,
+ ws: WS,
scope: Option<&str>,
name: &str,
args: &[Expr],
@@ -466,25 +466,25 @@ impl<'a> Generator<'a> {
self.flush_ws(ws); // Cannot handle_ws() here: whitespace from macro definition comes first
self.locals.push();
self.writeln("{");
- self.prepare_ws(&def.ws1);
+ self.prepare_ws(def.ws1);
for (i, arg) in def.args.iter().enumerate() {
let expr_code = self.visit_expr_root(
args.get(i)
- .expect(&format!("macro '{}' takes more than {} arguments", name, i)),
+ .unwrap_or_else(|| panic!("macro '{}' takes more than {} arguments", name, i)),
);
self.write(&format!("let {} = &{};", arg, expr_code));
self.locals.insert(arg);
}
self.handle(ctx, &def.nodes, AstLevel::Nested);
- self.flush_ws(&def.ws2);
+ self.flush_ws(def.ws2);
self.writeln("}");
self.locals.pop();
self.prepare_ws(ws);
}
- fn handle_include(&mut self, ctx: &'a Context, ws: &WS, path: &str) {
+ fn handle_include(&mut self, ctx: &'a Context, ws: WS, path: &str) {
self.flush_ws(ws);
let path = path::find_template_from_path(path, Some(&self.input.path));
let src = path::get_template_source(&path);
@@ -498,7 +498,7 @@ impl<'a> Generator<'a> {
self.prepare_ws(ws);
}
- fn write_let_decl(&mut self, ws: &WS, var: &'a Target) {
+ fn write_let_decl(&mut self, ws: WS, var: &'a Target) {
self.handle_ws(ws);
self.write("let ");
match *var {
@@ -510,7 +510,7 @@ impl<'a> Generator<'a> {
self.writeln(";");
}
- fn write_let(&mut self, ws: &WS, var: &'a Target, val: &Expr) {
+ fn write_let(&mut self, ws: WS, var: &'a Target, val: &Expr) {
self.handle_ws(ws);
let mut code = String::new();
self.visit_expr(val, &mut code);
@@ -527,14 +527,14 @@ impl<'a> Generator<'a> {
self.write(&format!(" = {};", &code));
}
- fn write_block(&mut self, ws1: &WS, name: &str, ws2: &WS) {
+ fn write_block(&mut self, ws1: WS, name: &str, ws2: WS) {
self.flush_ws(ws1);
let ctx = if self.impl_blocks { "timpl" } else { "self" };
self.writeln(&format!("{}.render_block_{}_into(writer)?;", ctx, name));
self.prepare_ws(ws2);
}
- fn write_expr(&mut self, ws: &WS, s: &Expr) {
+ fn write_expr(&mut self, ws: WS, s: &Expr) {
self.handle_ws(ws);
let mut code = String::new();
let wrapped = self.visit_expr(s, &mut code);
@@ -570,7 +570,7 @@ impl<'a> Generator<'a> {
}
}
- fn write_comment(&mut self, ws: &WS) {
+ fn write_comment(&mut self, ws: WS) {
self.handle_ws(ws);
}
@@ -824,7 +824,7 @@ impl<'a> Generator<'a> {
// Combines `flush_ws()` and `prepare_ws()` to handle both trailing whitespace from the
// preceding literal and leading whitespace from the succeeding literal.
- fn handle_ws(&mut self, ws: &WS) {
+ fn handle_ws(&mut self, ws: WS) {
self.flush_ws(ws);
self.prepare_ws(ws);
}
@@ -832,7 +832,7 @@ impl<'a> Generator<'a> {
// If the previous literal left some trailing whitespace in `next_ws` and the
// prefix whitespace suppressor from the given argument, flush that whitespace.
// In either case, `next_ws` is reset to `None` (no trailing whitespace).
- fn flush_ws(&mut self, ws: &WS) {
+ fn flush_ws(&mut self, ws: WS) {
if self.next_ws.is_some() && !ws.0 {
let val = self.next_ws.unwrap();
if !val.is_empty() {
@@ -845,7 +845,7 @@ impl<'a> Generator<'a> {
// Sets `skip_ws` to match the suffix whitespace suppressor from the given
// argument, to determine whether to suppress leading whitespace from the
// next literal.
- fn prepare_ws(&mut self, ws: &WS) {
+ fn prepare_ws(&mut self, ws: WS) {
self.skip_ws = ws.1;
}
diff --git a/askama_derive/src/parser.rs b/askama_derive/src/parser.rs
index 0538ab7..fb591d4 100644
--- a/askama_derive/src/parser.rs
+++ b/askama_derive/src/parser.rs
@@ -73,7 +73,7 @@ pub type When<'a> = (WS, Option<MatchVariant<'a>>, Vec<MatchParameter<'a>>, Vec<
type Input<'a> = nom::types::CompleteByteSlice<'a>;
#[allow(non_snake_case)]
-fn Input<'a>(input: &'a [u8]) -> Input<'a> {
+fn Input(input: &[u8]) -> Input {
nom::types::CompleteByteSlice(input)
}
generated by cgit (git 2.34.1) at 2024-11-25 07:10:00 +0000