Disconnect Buffer instance from Generator instance

1 files changed, 201 insertions, 195 deletions

diff --git a/askama_derive/src/generator.rs b/askama_derive/src/generator.rs
index a8d26b2..7cdad22 100644
--- a/askama_derive/src/generator.rs
+++ b/askama_derive/src/generator.rs
@@ -14,7 +14,7 @@ use std::{cmp, hash, str};
 use syn;
 
 pub(crate) fn generate(input: &TemplateInput, contexts: &HashMap<&PathBuf, Context>) -> String {
-    Generator::new(input, contexts, SetChain::new(), 0).build(&contexts[&input.path])
+    Generator::new(input, contexts, SetChain::new()).build(&contexts[&input.path])
 }
 
 struct Generator<'a> {
@@ -24,8 +24,6 @@ struct Generator<'a> {
     contexts: &'a HashMap<&'a PathBuf, Context<'a>>,
     // Variables accessible directly from the current scope (not redirected to context)
     locals: SetChain<'a, &'a str>,
-    // Top-level buffer for writing code into
-    buf: Buffer,
     // Suffix whitespace from the previous literal. Will be flushed to the
     // output buffer unless suppressed by whitespace suppression on the next
     // non-literal.
@@ -45,13 +43,11 @@ impl<'a> Generator<'a> {
         input: &'n TemplateInput,
         contexts: &'n HashMap<&'n PathBuf, Context<'n>>,
         locals: SetChain<'n, &'n str>,
-        indent: u8,
     ) -> Generator<'n> {
         Generator {
             input,
             contexts,
             locals,
-            buf: Buffer::new(indent),
             next_ws: None,
             skip_ws: false,
             super_block: None,
@@ -61,69 +57,75 @@ impl<'a> Generator<'a> {
 
     fn child(&mut self) -> Generator {
         let locals = SetChain::with_parent(&self.locals);
-        Self::new(self.input, self.contexts, locals, self.buf.indent)
+        Self::new(self.input, self.contexts, locals)
     }
 
     // Takes a Context and generates the relevant implementations.
     fn build(mut self, ctx: &'a Context) -> String {
+        let mut buf = Buffer::new(0);
         let heritage = if !ctx.blocks.is_empty() {
             if let Some(parent) = self.input.parent {
-                self.deref_to_parent(parent);
+                self.deref_to_parent(&mut buf, parent);
             }
             let heritage = Heritage::new(ctx, self.contexts);
-            self.trait_blocks(&heritage);
+            self.trait_blocks(&heritage, &mut buf);
             Some(heritage)
         } else {
             None
         };
 
-        self.impl_template(ctx, &heritage);
-        self.impl_display();
+        self.impl_template(ctx, &heritage, &mut buf);
+        self.impl_display(&mut buf);
         if cfg!(feature = "iron") {
-            self.impl_modifier_response();
+            self.impl_modifier_response(&mut buf);
         }
         if cfg!(feature = "rocket") {
-            self.impl_rocket_responder();
+            self.impl_rocket_responder(&mut buf);
         }
         if cfg!(feature = "actix-web") {
-            self.impl_actix_web_responder();
+            self.impl_actix_web_responder(&mut buf);
         }
-        self.buf.buf
+        buf.buf
     }
 
     // Implement `Template` for the given context struct.
-    fn impl_template(&mut self, ctx: &'a Context, heritage: &Option<Heritage<'a>>) {
-        self.write_header("::askama::Template", None);
-        self.buf.writeln(
+    fn impl_template(
+        &mut self,
+        ctx: &'a Context,
+        heritage: &Option<Heritage<'a>>,
+        buf: &mut Buffer,
+    ) {
+        self.write_header(buf, "::askama::Template", None);
+        buf.writeln(
             "fn render_into(&self, writer: &mut ::std::fmt::Write) -> \
              ::askama::Result<()> {",
         );
 
         if let Some(heritage) = heritage {
-            self.handle(heritage.root, heritage.root.nodes, AstLevel::Top);
+            self.handle(heritage.root, heritage.root.nodes, buf, AstLevel::Top);
         } else {
-            self.handle(ctx, &ctx.nodes, AstLevel::Top);
+            self.handle(ctx, &ctx.nodes, buf, AstLevel::Top);
         }
 
-        self.flush_ws(WS(false, false));
-        self.buf.writeln("Ok(())");
-        self.buf.writeln("}");
+        self.flush_ws(buf, WS(false, false));
+        buf.writeln("Ok(())");
+        buf.writeln("}");
 
-        self.buf.writeln("fn extension(&self) -> Option<&str> {");
-        self.buf.writeln(&format!(
+        buf.writeln("fn extension(&self) -> Option<&str> {");
+        buf.writeln(&format!(
             "{:?}",
             self.input.path.extension().map(|s| s.to_str().unwrap())
         ));
-        self.buf.writeln("}");
+        buf.writeln("}");
 
-        self.buf.writeln("}");
+        buf.writeln("}");
     }
 
-    fn trait_blocks(&mut self, heritage: &Heritage<'a>) {
+    fn trait_blocks(&mut self, heritage: &Heritage<'a>, buf: &mut Buffer) {
         let trait_name = format!("{}Blocks", self.input.ast.ident);
         let mut methods = vec![];
 
-        self.write_header(&trait_name, None);
+        self.write_header(buf, &trait_name, None);
         for blocks in heritage.blocks.values() {
             for (gen, (ctx, def)) in blocks.iter().enumerate() {
                 self.used_super = false;
@@ -134,8 +136,8 @@ impl<'a> Generator<'a> {
                         format!("{}_g{}", name, gen)
                     };
 
-                    self.buf.writeln("#[allow(unused_variables)]");
-                    self.buf.writeln(&format!(
+                    buf.writeln("#[allow(unused_variables)]");
+                    buf.writeln(&format!(
                         "fn render_block_{}_into(&self, writer: &mut ::std::fmt::Write) \
                          -> ::askama::Result<()> {{",
                         fname
@@ -145,13 +147,13 @@ impl<'a> Generator<'a> {
 
                     self.locals.push();
                     self.super_block = Some(format!("{}_g{}", name, gen + 1));
-                    self.handle(ctx, nodes, AstLevel::Block);
+                    self.handle(ctx, nodes, buf, AstLevel::Block);
                     self.super_block = None;
                     self.locals.pop();
 
-                    self.flush_ws(*ws2);
-                    self.buf.writeln("Ok(())");
-                    self.buf.writeln("}");
+                    self.flush_ws(buf, *ws2);
+                    buf.writeln("Ok(())");
+                    buf.writeln("}");
                 } else {
                     panic!("only block definitions allowed here");
                 }
@@ -161,50 +163,50 @@ impl<'a> Generator<'a> {
                 }
             }
         }
-        self.buf.writeln("}");
+        buf.writeln("}");
 
-        self.buf.writeln(&format!("pub trait {} {{", trait_name));
+        buf.writeln(&format!("pub trait {} {{", trait_name));
         for name in methods {
-            self.buf.writeln(&format!(
+            buf.writeln(&format!(
                 "fn render_block_{}_into(&self, writer: &mut ::std::fmt::Write) \
                  -> ::askama::Result<()>;",
                 name
             ));
         }
-        self.buf.writeln("}");
+        buf.writeln("}");
     }
 
     // Implement `Deref<Parent>` for an inheriting context struct.
-    fn deref_to_parent(&mut self, parent_type: &syn::Type) {
-        self.write_header("::std::ops::Deref", None);
-        self.buf.writeln(&format!(
+    fn deref_to_parent(&mut self, buf: &mut Buffer, parent_type: &syn::Type) {
+        self.write_header(buf, "::std::ops::Deref", None);
+        buf.writeln(&format!(
             "type Target = {};",
             parent_type.into_token_stream()
         ));
-        self.buf.writeln("fn deref(&self) -> &Self::Target {");
-        self.buf.writeln("&self._parent");
-        self.buf.writeln("}");
-        self.buf.writeln("}");
+        buf.writeln("fn deref(&self) -> &Self::Target {");
+        buf.writeln("&self._parent");
+        buf.writeln("}");
+        buf.writeln("}");
     }
 
     // Implement `Display` for the given context struct.
-    fn impl_display(&mut self) {
-        self.write_header("::std::fmt::Display", None);
-        self.buf
-            .writeln("fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {");
-        self.buf
-            .writeln("self.render_into(f).map_err(|_| ::std::fmt::Error {})");
-        self.buf.writeln("}");
-        self.buf.writeln("}");
+    fn impl_display(&mut self, buf: &mut Buffer) {
+        self.write_header(buf, "::std::fmt::Display", None);
+        buf.writeln("fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {");
+        buf.writeln("self.render_into(f).map_err(|_| ::std::fmt::Error {})");
+        buf.writeln("}");
+        buf.writeln("}");
     }
 
     // Implement iron's Modifier<Response> if enabled
-    fn impl_modifier_response(&mut self) {
-        self.write_header("::askama::iron::Modifier<::askama::iron::Response>", None);
-        self.buf
-            .writeln("fn modify(self, res: &mut ::askama::iron::Response) {");
-        self.buf
-            .writeln("res.body = Some(Box::new(self.render().unwrap().into_bytes()));");
+    fn impl_modifier_response(&mut self, buf: &mut Buffer) {
+        self.write_header(
+            buf,
+            "::askama::iron::Modifier<::askama::iron::Response>",
+            None,
+        );
+        buf.writeln("fn modify(self, res: &mut ::askama::iron::Response) {");
+        buf.writeln("res.body = Some(Box::new(self.render().unwrap().into_bytes()));");
 
         let ext = self.input
             .path
@@ -212,22 +214,25 @@ impl<'a> Generator<'a> {
             .map_or("", |s| s.to_str().unwrap_or(""));
         match ext {
             "html" | "htm" => {
-                self.buf
-                    .writeln("::askama::iron::ContentType::html().0.modify(res);");
+                buf.writeln("::askama::iron::ContentType::html().0.modify(res);");
             }
             _ => (),
         };
 
-        self.buf.writeln("}");
-        self.buf.writeln("}");
+        buf.writeln("}");
+        buf.writeln("}");
     }
 
     // Implement Rocket's `Responder`.
-    fn impl_rocket_responder(&mut self) {
+    fn impl_rocket_responder(&mut self, buf: &mut Buffer) {
         let lifetime = syn::Lifetime::new("'askama", Span::call_site());
         let param = syn::GenericParam::Lifetime(syn::LifetimeDef::new(lifetime));
-        self.write_header("::askama::rocket::Responder<'askama>", Some(vec![param]));
-        self.buf.writeln(
+        self.write_header(
+            buf,
+            "::askama::rocket::Responder<'askama>",
+            Some(vec![param]),
+        );
+        buf.writeln(
             "fn respond_to(self, _: &::askama::rocket::Request) \
              -> ::askama::rocket::Result<'askama> {",
         );
@@ -236,20 +241,18 @@ impl<'a> Generator<'a> {
             Some(s) => s.to_str().unwrap(),
             None => "txt",
         };
-        self.buf
-            .writeln(&format!("::askama::rocket::respond(&self, {:?})", ext));
+        buf.writeln(&format!("::askama::rocket::respond(&self, {:?})", ext));
 
-        self.buf.writeln("}");
-        self.buf.writeln("}");
+        buf.writeln("}");
+        buf.writeln("}");
     }
 
     // Implement Actix-web's `Responder`.
-    fn impl_actix_web_responder(&mut self) {
-        self.write_header("::askama::actix_web::Responder", None);
-        self.buf
-            .writeln("type Item = ::askama::actix_web::HttpResponse;");
-        self.buf.writeln("type Error = ::askama::actix_web::Error;");
-        self.buf.writeln(
+    fn impl_actix_web_responder(&mut self, buf: &mut Buffer) {
+        self.write_header(buf, "::askama::actix_web::Responder", None);
+        buf.writeln("type Item = ::askama::actix_web::HttpResponse;");
+        buf.writeln("type Error = ::askama::actix_web::Error;");
+        buf.writeln(
             "fn respond_to<S>(self, _req: &::askama::actix_web::HttpRequest<S>) \
              -> Result<Self::Item, Self::Error> {",
         );
@@ -258,16 +261,20 @@ impl<'a> Generator<'a> {
             Some(s) => s.to_str().unwrap(),
             None => "txt",
         };
-        self.buf
-            .writeln(&format!("::askama::actix_web::respond(&self, {:?})", ext));
+        buf.writeln(&format!("::askama::actix_web::respond(&self, {:?})", ext));
 
-        self.buf.writeln("}");
-        self.buf.writeln("}");
+        buf.writeln("}");
+        buf.writeln("}");
     }
 
     // Writes header for the `impl` for `TraitFromPathName` or `Template`
     // for the given context struct.
-    fn write_header(&mut self, target: &str, params: Option<Vec<syn::GenericParam>>) {
+    fn write_header(
+        &mut self,
+        buf: &mut Buffer,
+        target: &str,
+        params: Option<Vec<syn::GenericParam>>,
+    ) {
         let mut generics = self.input.ast.generics.clone();
         if let Some(params) = params {
             for param in params {
@@ -276,7 +283,7 @@ impl<'a> Generator<'a> {
         }
         let (_, orig_ty_generics, _) = self.input.ast.generics.split_for_impl();
         let (impl_generics, _, where_clause) = generics.split_for_impl();
-        self.buf.writeln(
+        buf.writeln(
             format!(
                 "{} {} for {}{} {{",
                 quote!(impl#impl_generics),
@@ -289,32 +296,32 @@ impl<'a> Generator<'a> {
 
     /* Helper methods for handling node types */
 
-    fn handle(&mut self, ctx: &'a Context, nodes: &'a [Node], level: AstLevel) {
+    fn handle(&mut self, ctx: &'a Context, nodes: &'a [Node], buf: &mut Buffer, level: AstLevel) {
         for n in nodes {
             match *n {
                 Node::Lit(lws, val, rws) => {
-                    self.write_lit(lws, val, rws);
+                    self.write_lit(buf, lws, val, rws);
                 }
                 Node::Comment(ws) => {
-                    self.write_comment(ws);
+                    self.write_comment(buf, ws);
                 }
                 Node::Expr(ws, ref val) => {
-                    self.write_expr(ws, val);
+                    self.write_expr(buf, ws, val);
                 }
                 Node::LetDecl(ws, ref var) => {
-                    self.write_let_decl(ws, var);
+                    self.write_let_decl(buf, ws, var);
                 }
                 Node::Let(ws, ref var, ref val) => {
-                    self.write_let(ws, var, val);
+                    self.write_let(buf, ws, var, val);
                 }
                 Node::Cond(ref conds, ws) => {
-                    self.write_cond(ctx, conds, ws);
+                    self.write_cond(ctx, buf, conds, ws);
                 }
                 Node::Match(ws1, ref expr, inter, ref arms, ws2) => {
-                    self.write_match(ctx, ws1, expr, inter, arms, ws2);
+                    self.write_match(ctx, buf, ws1, expr, inter, arms, ws2);
                 }
                 Node::Loop(ws1, ref var, ref iter, ref body, ws2) => {
-                    self.write_loop(ctx, ws1, var, iter, body, ws2);
+                    self.write_loop(ctx, buf, ws1, var, iter, body, ws2);
                 }
                 Node::BlockDef(ws1, name, _, ws2) => {
                     if let AstLevel::Nested = level {
@@ -324,26 +331,26 @@ impl<'a> Generator<'a> {
                             name
                         );
                     }
-                    self.write_block(ws1, name, ws2);
+                    self.write_block(buf, ws1, name, ws2);
                 }
                 Node::Include(ws, path) => {
-                    self.handle_include(ctx, ws, path);
+                    self.handle_include(ctx, buf, ws, path);
                 }
                 Node::Call(ws, scope, name, ref args) => {
-                    self.write_call(ctx, ws, scope, name, args);
+                    self.write_call(ctx, buf, 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.flush_ws(buf, m.ws1);
                     self.prepare_ws(m.ws2);
                 }
                 Node::Import(ws, _, _) => {
                     if level != AstLevel::Top {
                         panic!("import blocks only allowed at the top level");
                     }
-                    self.handle_ws(ws);
+                    self.handle_ws(buf, ws);
                 }
                 Node::Extends(_) => {
                     if level != AstLevel::Top {
@@ -356,44 +363,45 @@ impl<'a> Generator<'a> {
         }
     }
 
-    fn write_cond(&mut self, ctx: &'a Context, conds: &'a [Cond], ws: WS) {
+    fn write_cond(&mut self, ctx: &'a Context, buf: &mut Buffer, conds: &'a [Cond], ws: WS) {
         for (i, &(cws, ref cond, ref nodes)) in conds.iter().enumerate() {
-            self.handle_ws(cws);
+            self.handle_ws(buf, cws);
             match *cond {
                 Some(ref expr) => {
                     let expr_code = self.visit_expr_root(expr);
                     if i == 0 {
-                        self.buf.write("if ");
+                        buf.write("if ");
                     } else {
-                        self.buf.dedent();
-                        self.buf.write("} else if ");
+                        buf.dedent();
+                        buf.write("} else if ");
                     }
-                    self.buf.write(&expr_code);
+                    buf.write(&expr_code);
                 }
                 None => {
-                    self.buf.dedent();
-                    self.buf.write("} else");
+                    buf.dedent();
+                    buf.write("} else");
                 }
             }
-            self.buf.writeln(" {");
+            buf.writeln(" {");
             self.locals.push();
-            self.handle(ctx, nodes, AstLevel::Nested);
+            self.handle(ctx, nodes, buf, AstLevel::Nested);
             self.locals.pop();
         }
-        self.handle_ws(ws);
-        self.buf.writeln("}");
+        self.handle_ws(buf, ws);
+        buf.writeln("}");
     }
 
     fn write_match(
         &mut self,
         ctx: &'a Context,
+        buf: &mut Buffer,
         ws1: WS,
         expr: &Expr,
         inter: Option<&'a str>,
         arms: &'a [When],
         ws2: WS,
     ) {
-        self.flush_ws(ws1);
+        self.flush_ws(buf, ws1);
         if let Some(inter) = inter {
             if !inter.is_empty() {
                 self.next_ws = Some(inter);
@@ -401,83 +409,84 @@ impl<'a> Generator<'a> {
         }
 
         let expr_code = self.visit_expr_root(expr);
-        self.buf.writeln(&format!("match &{} {{", expr_code));
+        buf.writeln(&format!("match &{} {{", expr_code));
         for arm in arms {
             let &(ws, ref variant, ref params, ref body) = arm;
             self.locals.push();
             match *variant {
                 Some(ref param) => {
-                    self.visit_match_variant(param);
+                    self.visit_match_variant(buf, param);
                 }
-                None => self.buf.write("_"),
+                None => buf.write("_"),
             };
             if !params.is_empty() {
-                self.buf.write("(");
+                buf.write("(");
                 for (i, param) in params.iter().enumerate() {
                     if let MatchParameter::Name(p) = *param {
                         self.locals.insert(p);
                     }
                     if i > 0 {
-                        self.buf.write(", ");
+                        buf.write(", ");
                     }
-                    self.visit_match_param(param);
+                    self.visit_match_param(buf, param);
                 }
-                self.buf.write(")");
+                buf.write(")");
             }
-            self.buf.writeln(" => {");
-            self.handle_ws(ws);
-            self.handle(ctx, body, AstLevel::Nested);
-            self.buf.writeln("}");
+            buf.writeln(" => {");
+            self.handle_ws(buf, ws);
+            self.handle(ctx, body, buf, AstLevel::Nested);
+            buf.writeln("}");
             self.locals.pop();
         }
 
-        self.buf.writeln("}");
-        self.handle_ws(ws2);
+        buf.writeln("}");
+        self.handle_ws(buf, ws2);
     }
 
     fn write_loop(
         &mut self,
         ctx: &'a Context,
+        buf: &mut Buffer,
         ws1: WS,
         var: &'a Target,
         iter: &Expr,
         body: &'a [Node],
         ws2: WS,
     ) {
-        self.handle_ws(ws1);
+        self.handle_ws(buf, ws1);
         self.locals.push();
 
         let expr_code = self.visit_expr_root(iter);
-        self.buf.write("for (_loop_index, ");
+        buf.write("for (_loop_index, ");
         let targets = self.visit_target(var);
         for name in &targets {
             self.locals.insert(name);
-            self.buf.write(name);
+            buf.write(name);
         }
-        self.buf
-            .writeln(&format!(") in (&{}).into_iter().enumerate() {{", expr_code));
+        buf.writeln(&format!(") in (&{}).into_iter().enumerate() {{", expr_code));
 
-        self.handle(ctx, body, AstLevel::Nested);
-        self.handle_ws(ws2);
-        self.buf.writeln("}");
+        self.handle(ctx, body, buf, AstLevel::Nested);
+        self.handle_ws(buf, ws2);
+        buf.writeln("}");
         self.locals.pop();
     }
 
     fn write_call(
         &mut self,
         ctx: &'a Context,
+        buf: &mut Buffer,
         ws: WS,
         scope: Option<&str>,
         name: &str,
         args: &[Expr],
     ) {
         if name == "super" {
-            self.flush_ws(ws);
+            self.flush_ws(buf, ws);
             let line = match self.super_block {
                 Some(ref name) => format!("self.render_block_{}_into(writer)?;", name),
                 None => panic!("cannot call 'super()' outside block"),
             };
-            self.buf.writeln(&line);
+            buf.writeln(&line);
             self.prepare_ws(ws);
             self.used_super = true;
             return;
@@ -499,9 +508,9 @@ impl<'a> Generator<'a> {
                 .unwrap_or_else(|| panic!("macro '{}' not found", name))
         };
 
-        self.flush_ws(ws); // Cannot handle_ws() here: whitespace from macro definition comes first
+        self.flush_ws(buf, ws); // Cannot handle_ws() here: whitespace from macro definition comes first
         self.locals.push();
-        self.buf.writeln("{");
+        buf.writeln("{");
         self.prepare_ws(def.ws1);
 
         for (i, arg) in def.args.iter().enumerate() {
@@ -509,87 +518,84 @@ impl<'a> Generator<'a> {
                 args.get(i)
                     .unwrap_or_else(|| panic!("macro '{}' takes more than {} arguments", name, i)),
             );
-            self.buf.writeln(&format!("let {} = &{};", arg, expr_code));
+            buf.writeln(&format!("let {} = &{};", arg, expr_code));
             self.locals.insert(arg);
         }
-        self.handle(ctx, &def.nodes, AstLevel::Nested);
+        self.handle(ctx, &def.nodes, buf, AstLevel::Nested);
 
-        self.flush_ws(def.ws2);
-        self.buf.writeln("}");
+        self.flush_ws(buf, def.ws2);
+        buf.writeln("}");
         self.locals.pop();
         self.prepare_ws(ws);
     }
 
-    fn handle_include(&mut self, ctx: &'a Context, ws: WS, path: &str) {
-        self.flush_ws(ws);
+    fn handle_include(&mut self, ctx: &'a Context, buf: &mut Buffer, ws: WS, path: &str) {
+        self.flush_ws(buf, ws);
         let path = self.input
             .config
             .find_template(path, Some(&self.input.path));
         let src = get_template_source(&path);
         let nodes = parser::parse(&src);
-        let nested = {
+        {
             let mut gen = self.child();
-            gen.handle(ctx, &nodes, AstLevel::Nested);
-            gen.buf.buf
-        };
-        self.buf.write(&nested);
+            gen.handle(ctx, &nodes, buf, AstLevel::Nested);
+        }
         self.prepare_ws(ws);
     }
 
-    fn write_let_decl(&mut self, ws: WS, var: &'a Target) {
-        self.handle_ws(ws);
-        self.buf.write("let ");
+    fn write_let_decl(&mut self, buf: &mut Buffer, ws: WS, var: &'a Target) {
+        self.handle_ws(buf, ws);
+        buf.write("let ");
         match *var {
             Target::Name(name) => {
                 self.locals.insert(name);
-                self.buf.write(name);
+                buf.write(name);
             }
         }
-        self.buf.writeln(";");
+        buf.writeln(";");
     }
 
-    fn write_let(&mut self, ws: WS, var: &'a Target, val: &Expr) {
-        self.handle_ws(ws);
-        let mut buf = Buffer::new(0);
-        self.visit_expr(&mut buf, val);
+    fn write_let(&mut self, buf: &mut Buffer, ws: WS, var: &'a Target, val: &Expr) {
+        self.handle_ws(buf, ws);
+        let mut expr_buf = Buffer::new(0);
+        self.visit_expr(&mut expr_buf, val);
 
         match *var {
             Target::Name(name) => {
                 if !self.locals.contains(name) {
-                    self.buf.write("let ");
+                    buf.write("let ");
                     self.locals.insert(name);
                 }
-                self.buf.write(name);
+                buf.write(name);
             }
         }
-        self.buf.writeln(&format!(" = {};", &buf.buf));
+        buf.writeln(&format!(" = {};", &expr_buf.buf));
     }
 
-    fn write_block(&mut self, ws1: WS, name: &str, ws2: WS) {
-        self.flush_ws(ws1);
-        self.buf
-            .writeln(&format!("self.render_block_{}_into(writer)?;", name));
+    fn write_block(&mut self, buf: &mut Buffer, ws1: WS, name: &str, ws2: WS) {
+        self.flush_ws(buf, ws1);
+        buf.writeln(&format!("self.render_block_{}_into(writer)?;", name));
         self.prepare_ws(ws2);
     }
 
-    fn write_expr(&mut self, ws: WS, s: &Expr) {
-        self.handle_ws(ws);
-        let mut buf = Buffer::new(0);
-        let wrapped = self.visit_expr(&mut buf, s);
+    fn write_expr(&mut self, buf: &mut Buffer, ws: WS, s: &Expr) {
+        self.handle_ws(buf, ws);
+        let mut expr_buf = Buffer::new(0);
+        let wrapped = self.visit_expr(&mut expr_buf, s);
 
         use self::DisplayWrap::*;
         use super::input::EscapeMode::*;
-        self.buf.writeln("writer.write_fmt(format_args!(\"{}\", &{");
-        self.buf.write(&match (wrapped, &self.input.escaping) {
-            (Wrapped, &Html) | (Wrapped, &None) | (Unwrapped, &None) => buf.buf,
-            (Unwrapped, &Html) => format!("::askama::MarkupDisplay::from(&{})", buf.buf),
+        buf.writeln("writer.write_fmt(format_args!(\"{}\", &{");
+        buf.write(&match (wrapped, &self.input.escaping) {
+            (Wrapped, &Html) | (Wrapped, &None) | (Unwrapped, &None) => expr_buf.buf,
+            (Unwrapped, &Html) => format!("::askama::MarkupDisplay::from(&{})", expr_buf.buf),
         });
-        self.buf.writeln("");
-        self.buf.dedent();
-        self.buf.writeln("}))?;");
+        buf.writeln("");
+        buf.dedent();
+        buf.writeln("}))?;");
     }
 
-    fn write_lit(&mut self, lws: &'a str, val: &str, rws: &'a str) {
+    fn write_lit(&mut self, buf: &mut Buffer, lws: &'a str, val: &str, rws: &'a str) {
         assert!(self.next_ws.is_none());
         if !lws.is_empty() {
             if self.skip_ws {
@@ -598,19 +604,19 @@ impl<'a> Generator<'a> {
                 assert!(rws.is_empty());
                 self.next_ws = Some(lws);
             } else {
-                self.buf.writeln(&format!("writer.write_str({:#?})?;", lws));
+                buf.writeln(&format!("writer.write_str({:#?})?;", lws));
             }
         }
         if !val.is_empty() {
-            self.buf.writeln(&format!("writer.write_str({:#?})?;", val));
+            buf.writeln(&format!("writer.write_str({:#?})?;", val));
         }
         if !rws.is_empty() {
             self.next_ws = Some(rws);
         }
     }
 
-    fn write_comment(&mut self, ws: WS) {
-        self.handle_ws(ws);
+    fn write_comment(&mut self, buf: &mut Buffer, ws: WS) {
+        self.handle_ws(buf, ws);
     }
 
     /* Visitor methods for expression types */
@@ -641,38 +647,38 @@ impl<'a> Generator<'a> {
         }
     }
 
-    fn visit_match_variant(&mut self, param: &MatchVariant) -> DisplayWrap {
-        let mut buf = Buffer::new(0);
+    fn visit_match_variant(&mut self, buf: &mut Buffer, param: &MatchVariant) -> DisplayWrap {
+        let mut expr_buf = Buffer::new(0);
         let wrapped = match *param {
             MatchVariant::StrLit(s) => {
-                buf.write("&");
-                self.visit_str_lit(&mut buf, s)
+                expr_buf.write("&");
+                self.visit_str_lit(&mut expr_buf, s)
             }
-            MatchVariant::NumLit(s) => self.visit_num_lit(&mut buf, s),
+            MatchVariant::NumLit(s) => self.visit_num_lit(&mut expr_buf, s),
             MatchVariant::Name(s) => {
-                buf.write(s);
+                expr_buf.write(s);
                 DisplayWrap::Unwrapped
             }
             MatchVariant::Path(ref s) => {
-                buf.write(&s.join("::"));
+                expr_buf.write(&s.join("::"));
                 DisplayWrap::Unwrapped
             }
         };
-        self.buf.write(&buf.buf);
+        buf.write(&expr_buf.buf);
         wrapped
     }
 
-    fn visit_match_param(&mut self, param: &MatchParameter) -> DisplayWrap {
-        let mut buf = Buffer::new(0);
+    fn visit_match_param(&mut self, buf: &mut Buffer, param: &MatchParameter) -> DisplayWrap {
+        let mut expr_buf = Buffer::new(0);
         let wrapped = match *param {
-            MatchParameter::NumLit(s) => self.visit_num_lit(&mut buf, s),
-            MatchParameter::StrLit(s) => self.visit_str_lit(&mut buf, s),
+            MatchParameter::NumLit(s) => self.visit_num_lit(&mut expr_buf, s),
+            MatchParameter::StrLit(s) => self.visit_str_lit(&mut expr_buf, s),
             MatchParameter::Name(s) => {
-                buf.write(s);
+                expr_buf.write(s);
                 DisplayWrap::Unwrapped
             }
         };
-        self.buf.write(&buf.buf);
+        buf.write(&expr_buf.buf);
         wrapped
     }
 
@@ -891,19 +897,19 @@ 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) {
-        self.flush_ws(ws);
+    fn handle_ws(&mut self, buf: &mut Buffer, ws: WS) {
+        self.flush_ws(buf, ws);
         self.prepare_ws(ws);
     }
 
     // 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, buf: &mut Buffer, ws: WS) {
         if self.next_ws.is_some() && !ws.0 {
             let val = self.next_ws.unwrap();
             if !val.is_empty() {
-                self.buf.writeln(&format!("writer.write_str({:#?})?;", val));
+                buf.writeln(&format!("writer.write_str({:#?})?;", val));
             }
         }
         self.next_ws = None;