diff options
Diffstat (limited to 'askama_derive')
| -rw-r--r-- | askama_derive/src/generator.rs | 80 | ||||
| -rw-r--r-- | askama_derive/src/parser.rs | 2 |
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) } |