Move code generation into askama_shared

2 files changed, 12 insertions, 1509 deletions

diff --git a/askama_derive/src/generator.rs b/askama_derive/src/generator.rs
deleted file mode 100644
index a12b1f0..0000000
--- a/askama_derive/src/generator.rs
+++ /dev/null
@@ -1,1367 +0,0 @@
-use super::{get_template_source, Context, Heritage};
-use askama_shared::filters;
-use askama_shared::input::{Source, TemplateInput};
-use askama_shared::parser::{
-    parse, Cond, Expr, MatchParameter, MatchParameters, MatchVariant, Node, Target, When, WS,
-};
-
-use proc_macro2::Span;
-
-use quote::ToTokens;
-
-use std::collections::{HashMap, HashSet};
-use std::path::PathBuf;
-use std::{cmp, hash, mem, str};
-
-use syn;
-
-pub(crate) fn generate(
-    input: &TemplateInput,
-    contexts: &HashMap<&PathBuf, Context>,
-    heritage: &Option<Heritage>,
-) -> String {
-    Generator::new(input, contexts, heritage, SetChain::new()).build(&contexts[&input.path])
-}
-
-struct Generator<'a> {
-    // The template input state: original struct AST and attributes
-    input: &'a TemplateInput<'a>,
-    // All contexts, keyed by the package-relative template path
-    contexts: &'a HashMap<&'a PathBuf, Context<'a>>,
-    // The heritage contains references to blocks and their ancestry
-    heritage: &'a Option<Heritage<'a>>,
-    // Variables accessible directly from the current scope (not redirected to context)
-    locals: SetChain<'a, &'a str>,
-    // Suffix whitespace from the previous literal. Will be flushed to the
-    // output buffer unless suppressed by whitespace suppression on the next
-    // non-literal.
-    next_ws: Option<&'a str>,
-    // Whitespace suppression from the previous non-literal. Will be used to
-    // determine whether to flush prefix whitespace from the next literal.
-    skip_ws: bool,
-    // If currently in a block, this will contain the name of a potential parent block
-    super_block: Option<(&'a str, usize)>,
-    // buffer for writable
-    buf_writable: Vec<Writable<'a>>,
-    // Counter for write! hash named arguments
-    named: usize,
-}
-
-impl<'a> Generator<'a> {
-    fn new<'n>(
-        input: &'n TemplateInput,
-        contexts: &'n HashMap<&'n PathBuf, Context<'n>>,
-        heritage: &'n Option<Heritage>,
-        locals: SetChain<'n, &'n str>,
-    ) -> Generator<'n> {
-        Generator {
-            input,
-            contexts,
-            heritage,
-            locals,
-            next_ws: None,
-            skip_ws: false,
-            super_block: None,
-            buf_writable: vec![],
-            named: 0,
-        }
-    }
-
-    fn child(&mut self) -> Generator {
-        let locals = SetChain::with_parent(&self.locals);
-        Self::new(self.input, self.contexts, self.heritage, locals)
-    }
-
-    // Takes a Context and generates the relevant implementations.
-    fn build(mut self, ctx: &'a Context) -> String {
-        let mut buf = Buffer::new(0);
-        if !ctx.blocks.is_empty() {
-            if let Some(parent) = self.input.parent {
-                self.deref_to_parent(&mut buf, parent);
-            }
-        };
-
-        self.impl_template(ctx, &mut buf);
-        self.impl_display(&mut buf);
-        if cfg!(feature = "iron") {
-            self.impl_modifier_response(&mut buf);
-        }
-        if cfg!(feature = "rocket") {
-            self.impl_rocket_responder(&mut buf);
-        }
-        if cfg!(feature = "actix-web") {
-            self.impl_actix_web_responder(&mut buf);
-        }
-        if cfg!(feature = "gotham") {
-            self.impl_gotham_into_response(&mut buf);
-        }
-        if cfg!(feature = "warp") {
-            self.impl_warp_reply(&mut buf);
-        }
-        buf.buf
-    }
-
-    // Implement `Template` for the given context struct.
-    fn impl_template(&mut self, ctx: &'a Context, buf: &mut Buffer) {
-        self.write_header(buf, "::askama::Template", None);
-        buf.writeln(
-            "fn render_into(&self, writer: &mut ::std::fmt::Write) -> \
-             ::askama::Result<()> {",
-        );
-
-        // Make sure the compiler understands that the generated code depends on the template files.
-        for path in self.contexts.keys() {
-            // Skip the fake path of templates defined in rust source.
-            let path_is_valid = match self.input.source {
-                Source::Path(_) => true,
-                Source::Source(_) => *path != &self.input.path,
-            };
-            if path_is_valid {
-                let path = path.to_str().unwrap();
-                buf.writeln(
-                    &quote! {
-                        include_bytes!(#path);
-                    }
-                    .to_string(),
-                );
-            }
-        }
-
-        let size_hint = if let Some(heritage) = self.heritage {
-            self.handle(heritage.root, heritage.root.nodes, buf, AstLevel::Top)
-        } else {
-            self.handle(ctx, &ctx.nodes, buf, AstLevel::Top)
-        };
-
-        self.flush_ws(WS(false, false));
-        buf.writeln("Ok(())");
-        buf.writeln("}");
-
-        buf.writeln("fn extension(&self) -> Option<&'static str> {");
-        buf.writeln(&format!(
-            "{:?}",
-            self.input.path.extension().map(|s| s.to_str().unwrap())
-        ));
-        buf.writeln("}");
-
-        buf.writeln("fn size_hint(&self) -> usize {");
-        buf.writeln(&format!("{}", size_hint));
-        buf.writeln("}");
-
-        buf.writeln("}");
-
-        self.write_header(buf, "::askama::SizedTemplate", None);
-
-        buf.writeln("fn size_hint() -> usize {");
-        buf.writeln(&format!("{}", size_hint));
-        buf.writeln("}");
-
-        buf.writeln("fn extension() -> Option<&'static str> {");
-        buf.writeln(&format!(
-            "{:?}",
-            self.input.path.extension().map(|s| s.to_str().unwrap())
-        ));
-        buf.writeln("}");
-
-        buf.writeln("}");
-    }
-
-    // Implement `Deref<Parent>` for an inheriting context struct.
-    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()
-        ));
-        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, 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("::askama::Template::render_into(self, f).map_err(|_| ::std::fmt::Error {})");
-        buf.writeln("}");
-        buf.writeln("}");
-    }
-
-    // Implement iron's Modifier<Response> if enabled
-    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(::askama_iron::Template::render(&self).unwrap().into_bytes()));",
-        );
-
-        let ext = self
-            .input
-            .path
-            .extension()
-            .map_or("", |s| s.to_str().unwrap_or(""));
-        match ext {
-            "html" | "htm" => {
-                buf.writeln("::askama_iron::ContentType::html().0.modify(res);");
-            }
-            _ => (),
-        };
-
-        buf.writeln("}");
-        buf.writeln("}");
-    }
-
-    // Implement Rocket's `Responder`.
-    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(
-            buf,
-            "::askama_rocket::Responder<'askama>",
-            Some(vec![param]),
-        );
-        buf.writeln(
-            "fn respond_to(self, _: &::askama_rocket::Request) \
-             -> ::askama_rocket::Result<'askama> {",
-        );
-
-        let ext = match self.input.path.extension() {
-            Some(s) => s.to_str().unwrap(),
-            None => "txt",
-        };
-        buf.writeln(&format!("::askama_rocket::respond(&self, {:?})", ext));
-
-        buf.writeln("}");
-        buf.writeln("}");
-    }
-
-    // Implement Actix-web's `Responder`.
-    fn impl_actix_web_responder(&mut self, buf: &mut Buffer) {
-        self.write_header(buf, "::actix_web::Responder", None);
-        buf.writeln("type Future = ::futures::future::Ready<::std::result::Result<::actix_web::HttpResponse, Self::Error>>;");
-        buf.writeln("type Error = ::actix_web::Error;");
-        buf.writeln(
-            "fn respond_to(self, _req: &::actix_web::HttpRequest) \
-             -> Self::Future {",
-        );
-
-        buf.writeln("use ::askama_actix::TemplateIntoResponse;");
-        buf.writeln("::futures::future::ready(self.into_response())");
-
-        buf.writeln("}");
-        buf.writeln("}");
-    }
-
-    // Implement gotham's `IntoResponse`.
-    fn impl_gotham_into_response(&mut self, buf: &mut Buffer) {
-        self.write_header(buf, "::askama_gotham::IntoResponse", None);
-        buf.writeln(
-            "fn into_response(self, _state: &::askama_gotham::State)\
-             -> ::askama_gotham::Response<::askama_gotham::Body> {",
-        );
-        let ext = match self.input.path.extension() {
-            Some(s) => s.to_str().unwrap(),
-            None => "txt",
-        };
-        buf.writeln(&format!("::askama_gotham::respond(&self, {:?})", ext));
-        buf.writeln("}");
-        buf.writeln("}");
-    }
-
-    fn impl_warp_reply(&mut self, buf: &mut Buffer) {
-        self.write_header(buf, "::askama_warp::warp::reply::Reply", None);
-        buf.writeln("fn into_response(self) -> ::askama_warp::warp::reply::Response {");
-        let ext = self
-            .input
-            .path
-            .extension()
-            .and_then(|s| s.to_str())
-            .unwrap_or("txt");
-        buf.writeln(&format!("::askama_warp::reply(&self, {:?})", ext));
-        buf.writeln("}");
-        buf.writeln("}");
-    }
-
-    // Writes header for the `impl` for `TraitFromPathName` or `Template`
-    // for the given context struct.
-    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 {
-                generics.params.push(param);
-            }
-        }
-        let (_, orig_ty_generics, _) = self.input.ast.generics.split_for_impl();
-        let (impl_generics, _, where_clause) = generics.split_for_impl();
-        buf.writeln(
-            format!(
-                "{} {} for {}{} {{",
-                quote!(impl#impl_generics),
-                target,
-                self.input.ast.ident,
-                quote!(#orig_ty_generics #where_clause),
-            )
-            .as_ref(),
-        );
-    }
-
-    /* Helper methods for handling node types */
-
-    fn handle(
-        &mut self,
-        ctx: &'a Context,
-        nodes: &'a [Node],
-        buf: &mut Buffer,
-        level: AstLevel,
-    ) -> usize {
-        let mut size_hint = 0;
-        for n in nodes {
-            match *n {
-                Node::Lit(lws, val, rws) => {
-                    self.visit_lit(lws, val, rws);
-                }
-                Node::Comment(ws) => {
-                    self.write_comment(ws);
-                }
-                Node::Expr(ws, ref val) => {
-                    self.write_expr(ws, val);
-                }
-                Node::LetDecl(ws, ref var) => {
-                    self.write_let_decl(buf, ws, var);
-                }
-                Node::Let(ws, ref var, ref val) => {
-                    self.write_let(buf, ws, var, val);
-                }
-                Node::Cond(ref conds, ws) => {
-                    self.write_cond(ctx, buf, conds, ws);
-                }
-                Node::Match(ws1, ref expr, inter, ref 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, buf, ws1, var, iter, body, ws2);
-                }
-                Node::BlockDef(ws1, name, _, ws2) => {
-                    if AstLevel::Nested == level {
-                        panic!(
-                            "blocks ('{}') are only allowed at the top level of a template \
-                             or another block",
-                            name
-                        );
-                    }
-                    let outer = WS(ws1.0, ws2.1);
-                    self.write_block(buf, Some(name), outer);
-                }
-                Node::Include(ws, path) => {
-                    size_hint += self.handle_include(ctx, buf, ws, path);
-                }
-                Node::Call(ws, scope, name, ref args) => {
-                    size_hint += 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.prepare_ws(m.ws2);
-                }
-                Node::Raw(ws1, contents, ws2) => {
-                    self.handle_ws(ws1);
-                    self.buf_writable.push(Writable::Lit(contents));
-                    self.handle_ws(ws2);
-                }
-                Node::Import(ws, _, _) => {
-                    if level != AstLevel::Top {
-                        panic!("import blocks only allowed at the top level");
-                    }
-                    self.handle_ws(ws);
-                }
-                Node::Extends(_) => {
-                    if level != AstLevel::Top {
-                        panic!("extend blocks only allowed at the top level");
-                    }
-                    // No whitespace handling: child template top-level is not used,
-                    // except for the blocks defined in it.
-                }
-            }
-        }
-
-        if AstLevel::Top == level {
-            size_hint += self.write_buf_writable(buf);
-        }
-        size_hint
-    }
-
-    fn write_cond(
-        &mut self,
-        ctx: &'a Context,
-        buf: &mut Buffer,
-        conds: &'a [Cond],
-        ws: WS,
-    ) -> usize {
-        let mut flushed = 0;
-        let mut arm_sizes = Vec::new();
-        let mut has_else = false;
-        for (i, &(cws, ref cond, ref nodes)) in conds.iter().enumerate() {
-            self.handle_ws(cws);
-            if arm_sizes.is_empty() {
-                flushed += self.write_buf_writable(buf);
-            }
-
-            let mut arm_size = 0;
-            match *cond {
-                Some(ref expr) => {
-                    if i == 0 {
-                        buf.write("if ");
-                    } else {
-                        buf.dedent();
-                        buf.write("} else if ");
-                    }
-                    let expr_code = self.visit_expr_root(expr);
-                    buf.write(&expr_code);
-                }
-                None => {
-                    buf.dedent();
-                    buf.write("} else");
-                    has_else = true;
-                }
-            }
-
-            buf.writeln(" {");
-            self.locals.push();
-
-            arm_size += self.handle(ctx, nodes, buf, AstLevel::Nested);
-            arm_size += self.write_buf_writable(buf);
-            arm_sizes.push(arm_size);
-
-            self.locals.pop();
-        }
-        self.handle_ws(ws);
-        buf.writeln("}");
-
-        if !has_else {
-            arm_sizes.push(0);
-        }
-        flushed + median(&mut arm_sizes)
-    }
-
-    #[allow(clippy::too_many_arguments)]
-    fn write_match(
-        &mut self,
-        ctx: &'a Context,
-        buf: &mut Buffer,
-        ws1: WS,
-        expr: &Expr,
-        inter: Option<&'a str>,
-        arms: &'a [When],
-        ws2: WS,
-    ) -> usize {
-        self.flush_ws(ws1);
-        let flushed = self.write_buf_writable(buf);
-        let mut arm_sizes = Vec::new();
-        if let Some(inter) = inter {
-            if !inter.is_empty() {
-                self.next_ws = Some(inter);
-            }
-        }
-
-        let expr_code = self.visit_expr_root(expr);
-        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(buf, param);
-                }
-                None => buf.write("_"),
-            };
-
-            match params {
-                MatchParameters::Simple(params) => {
-                    if !params.is_empty() {
-                        buf.write("(");
-                        for (i, param) in params.iter().enumerate() {
-                            if let MatchParameter::Name(p) = *param {
-                                self.locals.insert(p);
-                            }
-                            if i > 0 {
-                                buf.write(", ");
-                            }
-                            self.visit_match_param(buf, param);
-                        }
-                        buf.write(")");
-                    }
-                }
-                MatchParameters::Named(params) => {
-                    buf.write("{");
-                    for (i, param) in params.iter().enumerate() {
-                        if let Some(MatchParameter::Name(p)) = param.1 {
-                            self.locals.insert(p);
-                        } else {
-                            self.locals.insert(param.0);
-                        }
-
-                        if i > 0 {
-                            buf.write(", ");
-                        }
-                        buf.write(param.0);
-                        if let Some(param) = &param.1 {
-                            buf.write(":");
-                            self.visit_match_param(buf, &param);
-                        }
-                    }
-                    buf.write("}");
-                }
-            }
-            buf.writeln(" => {");
-            self.handle_ws(ws);
-            let arm_size = self.handle(ctx, body, buf, AstLevel::Nested);
-            arm_sizes.push(arm_size + self.write_buf_writable(buf));
-            buf.writeln("}");
-            self.locals.pop();
-        }
-
-        buf.writeln("}");
-        self.handle_ws(ws2);
-        flushed + median(&mut arm_sizes)
-    }
-
-    #[allow(clippy::too_many_arguments)]
-    fn write_loop(
-        &mut self,
-        ctx: &'a Context,
-        buf: &mut Buffer,
-        ws1: WS,
-        var: &'a Target,
-        iter: &Expr,
-        body: &'a [Node],
-        ws2: WS,
-    ) -> usize {
-        self.handle_ws(ws1);
-        self.locals.push();
-
-        let expr_code = self.visit_expr_root(iter);
-
-        let flushed = self.write_buf_writable(buf);
-        buf.write("for (");
-        self.visit_target(buf, var);
-        match iter {
-            Expr::Range(_, _, _) => buf.writeln(&format!(
-                ", _loop_item) in ::askama::helpers::TemplateLoop::new({}) {{",
-                expr_code
-            )),
-            _ => buf.writeln(&format!(
-                ", _loop_item) in ::askama::helpers::TemplateLoop::new((&{}).into_iter()) {{",
-                expr_code
-            )),
-        };
-
-        let mut size_hint = self.handle(ctx, body, buf, AstLevel::Nested);
-        self.handle_ws(ws2);
-
-        size_hint += self.write_buf_writable(buf);
-        buf.writeln("}");
-        self.locals.pop();
-        flushed + (size_hint * 3)
-    }
-
-    fn write_call(
-        &mut self,
-        ctx: &'a Context,
-        buf: &mut Buffer,
-        ws: WS,
-        scope: Option<&str>,
-        name: &str,
-        args: &[Expr],
-    ) -> usize {
-        if name == "super" {
-            return self.write_block(buf, None, ws);
-        }
-
-        let (def, own_ctx) = if let Some(s) = scope {
-            let path = ctx
-                .imports
-                .get(s)
-                .unwrap_or_else(|| panic!("no import found for scope '{}'", s));
-            let mctx = self
-                .contexts
-                .get(path)
-                .unwrap_or_else(|| panic!("context for '{:?}' not found", path));
-            (
-                mctx.macros
-                    .get(name)
-                    .unwrap_or_else(|| panic!("macro '{}' not found in scope '{}'", s, name)),
-                mctx,
-            )
-        } else {
-            (
-                ctx.macros
-                    .get(name)
-                    .unwrap_or_else(|| panic!("macro '{}' not found", name)),
-                ctx,
-            )
-        };
-
-        self.flush_ws(ws); // Cannot handle_ws() here: whitespace from macro definition comes first
-        self.locals.push();
-        self.write_buf_writable(buf);
-        buf.writeln("{");
-        self.prepare_ws(def.ws1);
-
-        for (i, arg) in def.args.iter().enumerate() {
-            let expr_code = self.visit_expr_root(
-                args.get(i)
-                    .unwrap_or_else(|| panic!("macro '{}' takes more than {} arguments", name, i)),
-            );
-            buf.writeln(&format!("let {} = &{};", arg, expr_code));
-            self.locals.insert(arg);
-        }
-
-        let mut size_hint = self.handle(own_ctx, &def.nodes, buf, AstLevel::Nested);
-
-        self.flush_ws(def.ws2);
-        size_hint += self.write_buf_writable(buf);
-        buf.writeln("}");
-        self.locals.pop();
-        self.prepare_ws(ws);
-        size_hint
-    }
-
-    fn handle_include(&mut self, ctx: &'a Context, buf: &mut Buffer, ws: WS, path: &str) -> usize {
-        self.flush_ws(ws);
-        self.write_buf_writable(buf);
-        let path = self
-            .input
-            .config
-            .find_template(path, Some(&self.input.path));
-        let src = get_template_source(&path);
-        let nodes = parse(&src, self.input.syntax);
-
-        // Make sure the compiler understands that the generated code depends on the template file.
-        {
-            let path = path.to_str().unwrap();
-            buf.writeln(
-                &quote! {
-                    include_bytes!(#path);
-                }
-                .to_string(),
-            );
-        }
-
-        let size_hint = {
-            // Since nodes must not outlive the Generator, we instantiate
-            // a nested Generator here to handle the include's nodes.
-            let mut gen = self.child();
-            let mut size_hint = gen.handle(ctx, &nodes, buf, AstLevel::Nested);
-            size_hint += gen.write_buf_writable(buf);
-            size_hint
-        };
-        self.prepare_ws(ws);
-        size_hint
-    }
-
-    fn write_let_decl(&mut self, buf: &mut Buffer, ws: WS, var: &'a Target) {
-        self.handle_ws(ws);
-        self.write_buf_writable(buf);
-        buf.write("let ");
-        match *var {
-            Target::Name(name) => {
-                self.locals.insert(name);
-                buf.write(name);
-            }
-            Target::Tuple(ref targets) => {
-                buf.write("(");
-                for name in targets {
-                    self.locals.insert(name);
-                    buf.write(name);
-                    buf.write(",");
-                }
-                buf.write(")");
-            }
-        }
-        buf.writeln(";");
-    }
-
-    fn write_let(&mut self, buf: &mut Buffer, ws: WS, var: &'a Target, val: &Expr) {
-        self.handle_ws(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) {
-                    buf.write("let ");
-                    self.locals.insert(name);
-                }
-                buf.write(name);
-            }
-            Target::Tuple(ref targets) => {
-                buf.write("let (");
-                for name in targets {
-                    self.locals.insert(name);
-                    buf.write(name);
-                    buf.write(",");
-                }
-                buf.write(")");
-            }
-        }
-        buf.writeln(&format!(" = {};", &expr_buf.buf));
-    }
-
-    // If `name` is `Some`, this is a call to a block definition, and we have to find
-    // the first block for that name from the ancestry chain. If name is `None`, this
-    // is from a `super()` call, and we can get the name from `self.super_block`.
-    fn write_block(&mut self, buf: &mut Buffer, name: Option<&'a str>, outer: WS) -> usize {
-        // Flush preceding whitespace according to the outer WS spec
-        self.flush_ws(outer);
-
-        let prev_block = self.super_block;
-        let cur = match (name, prev_block) {
-            // The top-level context contains a block definition
-            (Some(cur_name), None) => (cur_name, 0),
-            // A block definition contains a block definition of the same name
-            (Some(cur_name), Some((prev_name, _))) if cur_name == prev_name => {
-                panic!("cannot define recursive blocks ({})", cur_name)
-            }
-            // A block definition contains a definition of another block
-            (Some(cur_name), Some((_, _))) => (cur_name, 0),
-            // `super()` was called inside a block
-            (None, Some((prev_name, gen))) => (prev_name, gen + 1),
-            // `super()` is called from outside a block
-            (None, None) => panic!("cannot call 'super()' outside block"),
-        };
-        self.super_block = Some(cur);
-
-        // Get the block definition from the heritage chain
-        let heritage = self
-            .heritage
-            .as_ref()
-            .unwrap_or_else(|| panic!("no block ancestors available"));
-        let (ctx, def) = heritage.blocks[cur.0]
-            .get(cur.1)
-            .unwrap_or_else(|| match name {
-                None => panic!("no super() block found for block '{}'", cur.0),
-                Some(name) => panic!("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.locals.push();
-        let size_hint = self.handle(ctx, nodes, buf, AstLevel::Block);
-
-        if !self.locals.is_current_empty() {
-            // Need to flush the buffer before popping the variable stack
-            self.write_buf_writable(buf);
-        }
-
-        self.locals.pop();
-        self.flush_ws(*ws2);
-
-        // Restore original block context and set whitespace suppression for
-        // succeeding whitespace according to the outer WS spec
-        self.super_block = prev_block;
-        self.prepare_ws(outer);
-        size_hint
-    }
-
-    fn write_expr(&mut self, ws: WS, s: &'a Expr<'a>) {
-        self.handle_ws(ws);
-        self.buf_writable.push(Writable::Expr(s));
-    }
-
-    // Write expression buffer and empty
-    fn write_buf_writable(&mut self, buf: &mut Buffer) -> usize {
-        if self.buf_writable.is_empty() {
-            return 0;
-        }
-
-        if self.buf_writable.iter().all(|w| match w {
-            Writable::Lit(_) => true,
-            _ => false,
-        }) {
-            let mut buf_lit = Buffer::new(0);
-            for s in mem::replace(&mut self.buf_writable, vec![]) {
-                if let Writable::Lit(s) = s {
-                    buf_lit.write(s);
-                };
-            }
-            buf.writeln(&format!("writer.write_str({:#?})?;", &buf_lit.buf));
-            return buf_lit.buf.len();
-        }
-
-        let mut size_hint = 0;
-        let mut buf_format = Buffer::new(0);
-        let mut buf_expr = Buffer::new(buf.indent + 1);
-        let mut expr_cache = HashMap::with_capacity(self.buf_writable.len());
-        for s in mem::replace(&mut self.buf_writable, vec![]) {
-            match s {
-                Writable::Lit(s) => {
-                    buf_format.write(&s.replace("{", "{{").replace("}", "}}"));
-                    size_hint += s.len();
-                }
-                Writable::Expr(s) => {
-                    use self::DisplayWrap::*;
-                    let mut expr_buf = Buffer::new(0);
-                    let wrapped = self.visit_expr(&mut expr_buf, s);
-                    let expression = match wrapped {
-                        Wrapped => expr_buf.buf,
-                        Unwrapped => format!(
-                            "::askama::MarkupDisplay::new_unsafe(&{}, {})",
-                            expr_buf.buf, self.input.escaper
-                        ),
-                    };
-
-                    let id = expr_cache.entry(expression.clone()).or_insert_with(|| {
-                        let id = self.named;
-                        self.named += 1;
-
-                        buf_expr.write(&format!("expr{} = ", id));
-                        buf_expr.write("&");
-                        buf_expr.write(&expression);
-                        buf_expr.writeln(",");
-
-                        id
-                    });
-
-                    buf_format.write(&format!("{{expr{}}}", id));
-                    size_hint += 3;
-                }
-            }
-        }
-
-        buf.writeln("write!(");
-        buf.indent();
-        buf.writeln("writer,");
-        buf.writeln(&format!("{:#?},", &buf_format.buf));
-        buf.writeln(buf_expr.buf.trim());
-        buf.dedent();
-        buf.writeln(")?;");
-        size_hint
-    }
-
-    fn visit_lit(&mut self, lws: &'a str, val: &'a str, rws: &'a str) {
-        assert!(self.next_ws.is_none());
-        if !lws.is_empty() {
-            if self.skip_ws {
-                self.skip_ws = false;
-            } else if val.is_empty() {
-                assert!(rws.is_empty());
-                self.next_ws = Some(lws);
-            } else {
-                self.buf_writable.push(Writable::Lit(lws));
-            }
-        }
-
-        if !val.is_empty() {
-            self.buf_writable.push(Writable::Lit(val));
-        }
-
-        if !rws.is_empty() {
-            self.next_ws = Some(rws);
-        }
-    }
-
-    fn write_comment(&mut self, ws: WS) {
-        self.handle_ws(ws);
-    }
-
-    /* Visitor methods for expression types */
-
-    fn visit_expr_root(&mut self, expr: &Expr) -> String {
-        let mut buf = Buffer::new(0);
-        self.visit_expr(&mut buf, expr);
-        buf.buf
-    }
-
-    fn visit_expr(&mut self, buf: &mut Buffer, expr: &Expr) -> DisplayWrap {
-        match *expr {
-            Expr::BoolLit(s) => self.visit_bool_lit(buf, s),
-            Expr::NumLit(s) => self.visit_num_lit(buf, s),
-            Expr::StrLit(s) => self.visit_str_lit(buf, s),
-            Expr::CharLit(s) => self.visit_char_lit(buf, s),
-            Expr::Var(s) => self.visit_var(buf, s),
-            Expr::Path(ref path) => self.visit_path(buf, path),
-            Expr::Array(ref elements) => self.visit_array(buf, elements),
-            Expr::Attr(ref obj, name) => self.visit_attr(buf, obj, name),
-            Expr::Index(ref obj, ref key) => self.visit_index(buf, obj, key),
-            Expr::Filter(name, ref args) => self.visit_filter(buf, name, args),
-            Expr::Unary(op, ref inner) => self.visit_unary(buf, op, inner),
-            Expr::BinOp(op, ref left, ref right) => self.visit_binop(buf, op, left, right),
-            Expr::Range(op, ref left, ref right) => self.visit_range(buf, op, left, right),
-            Expr::Group(ref inner) => self.visit_group(buf, inner),
-            Expr::MethodCall(ref obj, method, ref args) => {
-                self.visit_method_call(buf, obj, method, args)
-            }
-            Expr::RustMacro(name, args) => self.visit_rust_macro(buf, name, args),
-        }
-    }
-
-    fn visit_rust_macro(&mut self, buf: &mut Buffer, name: &str, args: &str) -> DisplayWrap {
-        buf.write(name);
-        buf.write("!(");
-        buf.write(args);
-        buf.write(")");
-
-        DisplayWrap::Unwrapped
-    }
-
-    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) => {
-                expr_buf.write("&");
-                self.visit_str_lit(&mut expr_buf, s)
-            }
-            MatchVariant::CharLit(s) => self.visit_char_lit(&mut expr_buf, s),
-            MatchVariant::NumLit(s) => self.visit_num_lit(&mut expr_buf, s),
-            MatchVariant::Name(s) => {
-                expr_buf.write(s);
-                DisplayWrap::Unwrapped
-            }
-            MatchVariant::Path(ref s) => {
-                expr_buf.write(&s.join("::"));
-                DisplayWrap::Unwrapped
-            }
-        };
-        buf.write(&expr_buf.buf);
-        wrapped
-    }
-
-    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 expr_buf, s),
-            MatchParameter::StrLit(s) => self.visit_str_lit(&mut expr_buf, s),
-            MatchParameter::CharLit(s) => self.visit_char_lit(&mut expr_buf, s),
-            MatchParameter::Name(s) => {
-                expr_buf.write(s);
-                DisplayWrap::Unwrapped
-            }
-        };
-        buf.write(&expr_buf.buf);
-        wrapped
-    }
-
-    fn visit_filter(&mut self, buf: &mut Buffer, name: &str, args: &[Expr]) -> DisplayWrap {
-        if name == "format" {
-            self._visit_format_filter(buf, args);
-            return DisplayWrap::Unwrapped;
-        } else if name == "join" {
-            self._visit_join_filter(buf, args);
-            return DisplayWrap::Unwrapped;
-        }
-
-        if name == "escape" || name == "safe" || name == "e" || name == "json" {
-            buf.write(&format!(
-                "::askama::filters::{}({}, &",
-                name, self.input.escaper
-            ));
-        } else if filters::BUILT_IN_FILTERS.contains(&name) {
-            buf.write(&format!("::askama::filters::{}(&", name));
-        } else {
-            buf.write(&format!("filters::{}(&", name));
-        }
-
-        self._visit_args(buf, args);
-        buf.write(")?");
-        if name == "safe" || name == "escape" || name == "e" || name == "json" {
-            DisplayWrap::Wrapped
-        } else {
-            DisplayWrap::Unwrapped
-        }
-    }
-
-    fn _visit_format_filter(&mut self, buf: &mut Buffer, args: &[Expr]) {
-        buf.write("format!(");
-        self._visit_args(buf, args);
-        buf.write(")");
-    }
-
-    // Force type coercion on first argument to `join` filter (see #39).
-    fn _visit_join_filter(&mut self, buf: &mut Buffer, args: &[Expr]) {
-        buf.write("::askama::filters::join((&");
-        for (i, arg) in args.iter().enumerate() {
-            if i > 0 {
-                buf.write(", &");
-            }
-            self.visit_expr(buf, arg);
-            if i == 0 {
-                buf.write(").into_iter()");
-            }
-        }
-        buf.write(")?");
-    }
-
-    fn _visit_args(&mut self, buf: &mut Buffer, args: &[Expr]) {
-        for (i, arg) in args.iter().enumerate() {
-            if i > 0 {
-                buf.write(", &");
-            }
-
-            let scoped = match *arg {
-                Expr::Filter(_, _) | Expr::MethodCall(_, _, _) => true,
-                _ => false,
-            };
-
-            if scoped {
-                buf.writeln("{");
-                self.visit_expr(buf, arg);
-                buf.writeln("}");
-            } else {
-                self.visit_expr(buf, arg);
-            }
-        }
-    }
-
-    fn visit_attr(&mut self, buf: &mut Buffer, obj: &Expr, attr: &str) -> DisplayWrap {
-        if let Expr::Var(name) = *obj {
-            if name == "loop" {
-                if attr == "index" {
-                    buf.write("(_loop_item.index + 1)");
-                    return DisplayWrap::Unwrapped;
-                } else if attr == "index0" {
-                    buf.write("_loop_item.index");
-                    return DisplayWrap::Unwrapped;
-                } else if attr == "first" {
-                    buf.write("_loop_item.first");
-                    return DisplayWrap::Unwrapped;
-                } else if attr == "last" {
-                    buf.write("_loop_item.last");
-                    return DisplayWrap::Unwrapped;
-                } else {
-                    panic!("unknown loop variable");
-                }
-            }
-        }
-        self.visit_expr(buf, obj);
-        buf.write(&format!(".{}", attr));
-        DisplayWrap::Unwrapped
-    }
-
-    fn visit_index(&mut self, buf: &mut Buffer, obj: &Expr, key: &Expr) -> DisplayWrap {
-        buf.write("&");
-        self.visit_expr(buf, obj);
-        buf.write("[");
-        self.visit_expr(buf, key);
-        buf.write("]");
-        DisplayWrap::Unwrapped
-    }
-
-    fn visit_method_call(
-        &mut self,
-        buf: &mut Buffer,
-        obj: &Expr,
-        method: &str,
-        args: &[Expr],
-    ) -> DisplayWrap {
-        if let Expr::Var("self") = obj {
-            buf.write("self");
-        } else {
-            self.visit_expr(buf, obj);
-        }
-
-        buf.write(&format!(".{}(", method));
-        self._visit_args(buf, args);
-        buf.write(")");
-        DisplayWrap::Unwrapped
-    }
-
-    fn visit_unary(&mut self, buf: &mut Buffer, op: &str, inner: &Expr) -> DisplayWrap {
-        buf.write(op);
-        self.visit_expr(buf, inner);
-        DisplayWrap::Unwrapped
-    }
-
-    fn visit_range(
-        &mut self,
-        buf: &mut Buffer,
-        op: &str,
-        left: &Option<Box<Expr>>,
-        right: &Option<Box<Expr>>,
-    ) -> DisplayWrap {
-        if let Some(left) = left {
-            self.visit_expr(buf, left);
-        }
-        buf.write(op);
-        if let Some(right) = right {
-            self.visit_expr(buf, right);
-        }
-        DisplayWrap::Unwrapped
-    }
-
-    fn visit_binop(
-        &mut self,
-        buf: &mut Buffer,
-        op: &str,
-        left: &Expr,
-        right: &Expr,
-    ) -> DisplayWrap {
-        self.visit_expr(buf, left);
-        buf.write(&format!(" {} ", op));
-        self.visit_expr(buf, right);
-        DisplayWrap::Unwrapped
-    }
-
-    fn visit_group(&mut self, buf: &mut Buffer, inner: &Expr) -> DisplayWrap {
-        buf.write("(");
-        self.visit_expr(buf, inner);
-        buf.write(")");
-        DisplayWrap::Unwrapped
-    }
-
-    fn visit_array(&mut self, buf: &mut Buffer, elements: &[Expr]) -> DisplayWrap {
-        buf.write("[");
-        for (i, el) in elements.iter().enumerate() {
-            if i > 0 {
-                buf.write(", ");
-            }
-            self.visit_expr(buf, el);
-        }
-        buf.write("]");
-        DisplayWrap::Unwrapped
-    }
-
-    fn visit_path(&mut self, buf: &mut Buffer, path: &[&str]) -> DisplayWrap {
-        for (i, part) in path.iter().enumerate() {
-            if i > 0 {
-                buf.write("::");
-            }
-            buf.write(part);
-        }
-        DisplayWrap::Unwrapped
-    }
-
-    fn visit_var(&mut self, buf: &mut Buffer, s: &str) -> DisplayWrap {
-        if self.locals.contains(s) || s == "self" {
-            buf.write(s);
-        } else {
-            buf.write("self.");
-            buf.write(s);
-        }
-        DisplayWrap::Unwrapped
-    }
-
-    fn visit_bool_lit(&mut self, buf: &mut Buffer, s: &str) -> DisplayWrap {
-        buf.write(s);
-        DisplayWrap::Unwrapped
-    }
-
-    fn visit_str_lit(&mut self, buf: &mut Buffer, s: &str) -> DisplayWrap {
-        buf.write(&format!("\"{}\"", s));
-        DisplayWrap::Unwrapped
-    }
-
-    fn visit_char_lit(&mut self, buf: &mut Buffer, s: &str) -> DisplayWrap {
-        buf.write(&format!("'{}'", s));
-        DisplayWrap::Unwrapped
-    }
-
-    fn visit_num_lit(&mut self, buf: &mut Buffer, s: &str) -> DisplayWrap {
-        buf.write(s);
-        DisplayWrap::Unwrapped
-    }
-
-    fn visit_target(&mut self, buf: &mut Buffer, target: &'a Target) {
-        match *target {
-            Target::Name(name) => {
-                self.locals.insert(name);
-                buf.write(name);
-            }
-            Target::Tuple(ref targets) => {
-                buf.write("(");
-                for name in targets {
-                    self.locals.insert(name);
-                    buf.write(name);
-                    buf.write(",");
-                }
-                buf.write(")");
-            }
-        }
-    }
-
-    /* Helper methods for dealing with whitespace nodes */
-
-    // 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);
-        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) {
-        if self.next_ws.is_some() && !ws.0 {
-            let val = self.next_ws.unwrap();
-            if !val.is_empty() {
-                self.buf_writable.push(Writable::Lit(val));
-            }
-        }
-        self.next_ws = None;
-    }
-
-    // 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) {
-        self.skip_ws = ws.1;
-    }
-}
-
-struct Buffer {
-    // The buffer to generate the code into
-    buf: String,
-    // The current level of indentation (in spaces)
-    indent: u8,
-    // Whether the output buffer is currently at the start of a line
-    start: bool,
-}
-
-impl Buffer {
-    fn new(indent: u8) -> Self {
-        Self {
-            buf: String::new(),
-            indent,
-            start: true,
-        }
-    }
-
-    fn writeln(&mut self, s: &str) {
-        if s == "}" {
-            self.dedent();
-        }
-        if !s.is_empty() {
-            self.write(s);
-        }
-        self.buf.push('\n');
-        if s.ends_with('{') {
-            self.indent();
-        }
-        self.start = true;
-    }
-
-    fn write(&mut self, s: &str) {
-        if self.start {
-            for _ in 0..(self.indent * 4) {
-                self.buf.push(' ');
-            }
-            self.start = false;
-        }
-        self.buf.push_str(s);
-    }
-
-    fn indent(&mut self) {
-        self.indent += 1;
-    }
-
-    fn dedent(&mut self) {
-        if self.indent == 0 {
-            panic!("dedent() called while indentation == 0");
-        }
-        self.indent -= 1;
-    }
-}
-
-#[derive(Debug)]
-struct SetChain<'a, T: 'a>
-where
-    T: cmp::Eq + hash::Hash,
-{
-    parent: Option<&'a SetChain<'a, T>>,
-    scopes: Vec<HashSet<T>>,
-}
-
-impl<'a, T: 'a> SetChain<'a, T>
-where
-    T: cmp::Eq + hash::Hash,
-{
-    fn new() -> SetChain<'a, T> {
-        SetChain {
-            parent: None,
-            scopes: vec![HashSet::new()],
-        }
-    }
-
-    fn with_parent<'p>(parent: &'p SetChain<T>) -> SetChain<'p, T> {
-        SetChain {
-            parent: Some(parent),
-            scopes: vec![HashSet::new()],
-        }
-    }
-
-    fn contains(&self, val: T) -> bool {
-        self.scopes.iter().rev().any(|set| set.contains(&val))
-            || match self.parent {
-                Some(set) => set.contains(val),
-                None => false,
-            }
-    }
-
-    fn is_current_empty(&self) -> bool {
-        self.scopes.last().unwrap().is_empty()
-    }
-
-    fn insert(&mut self, val: T) {
-        self.scopes.last_mut().unwrap().insert(val);
-    }
-
-    fn push(&mut self) {
-        self.scopes.push(HashSet::new());
-    }
-
-    fn pop(&mut self) {
-        self.scopes.pop().unwrap();
-        assert!(!self.scopes.is_empty());
-    }
-}
-
-fn median(sizes: &mut [usize]) -> usize {
-    sizes.sort();
-    if sizes.len() % 2 == 1 {
-        sizes[sizes.len() / 2]
-    } else {
-        (sizes[sizes.len() / 2 - 1] + sizes[sizes.len() / 2]) / 2
-    }
-}
-
-#[derive(Clone, PartialEq)]
-enum AstLevel {
-    Top,
-    Block,
-    Nested,
-}
-
-impl Copy for AstLevel {}
-
-#[derive(Clone)]
-enum DisplayWrap {
-    Wrapped,
-    Unwrapped,
-}
-
-impl Copy for DisplayWrap {}
-
-#[derive(Debug)]
-enum Writable<'a> {
-    Lit(&'a str),
-    Expr(&'a Expr<'a>),
-}
diff --git a/askama_derive/src/lib.rs b/askama_derive/src/lib.rs
index 0b64057..fcd857d 100644
--- a/askama_derive/src/lib.rs
+++ b/askama_derive/src/lib.rs
@@ -1,17 +1,13 @@
 extern crate proc_macro;
-#[macro_use]
-extern crate quote;
-
-mod generator;
 
+use askama_shared::heritage::{Context, Heritage};
 use askama_shared::input::{Print, Source, TemplateInput};
-use askama_shared::parser::{parse, Expr, Macro, Node};
-use askama_shared::{read_config_file, Config};
+use askama_shared::parser::{parse, Expr, Node};
+use askama_shared::{generator, get_template_source, read_config_file, Config, Integrations};
 use proc_macro::TokenStream;
 
 use std::collections::HashMap;
-use std::fs;
-use std::path::{Path, PathBuf};
+use std::path::PathBuf;
 
 #[proc_macro_derive(Template, attributes(template))]
 pub fn derive_template(input: TokenStream) -> TokenStream {
@@ -59,7 +55,7 @@ fn build_template(ast: &syn::DeriveInput) -> String {
         eprintln!("{:?}", parsed[&input.path]);
     }
 
-    let code = generator::generate(&input, &contexts, &heritage);
+    let code = generator::generate(&input, &contexts, &heritage, INTEGRATIONS);
     if input.print == Print::Code || input.print == Print::All {
         eprintln!("{}", code);
     }
@@ -88,136 +84,10 @@ fn find_used_templates(input: &TemplateInput, map: &mut HashMap<PathBuf, String>
     }
 }
 
-pub(crate) struct Heritage<'a> {
-    root: &'a Context<'a>,
-    blocks: BlockAncestry<'a>,
-}
-
-impl<'a> Heritage<'a> {
-    fn new<'n>(
-        mut ctx: &'n Context<'n>,
-        contexts: &'n HashMap<&'n PathBuf, Context<'n>>,
-    ) -> Heritage<'n> {
-        let mut blocks: BlockAncestry<'n> = ctx
-            .blocks
-            .iter()
-            .map(|(name, def)| (*name, vec![(ctx, *def)]))
-            .collect();
-
-        while let Some(ref path) = ctx.extends {
-            ctx = &contexts[&path];
-            for (name, def) in &ctx.blocks {
-                blocks
-                    .entry(name)
-                    .or_insert_with(|| vec![])
-                    .push((ctx, def));
-            }
-        }
-
-        Heritage { root: ctx, blocks }
-    }
-}
-
-type BlockAncestry<'a> = HashMap<&'a str, Vec<(&'a Context<'a>, &'a Node<'a>)>>;
-
-pub(crate) struct Context<'a> {
-    nodes: &'a [Node<'a>],
-    extends: Option<PathBuf>,
-    blocks: HashMap<&'a str, &'a Node<'a>>,
-    macros: HashMap<&'a str, &'a Macro<'a>>,
-    imports: HashMap<&'a str, PathBuf>,
-}
-
-impl<'a> Context<'a> {
-    fn new<'n>(config: &Config, path: &Path, nodes: &'n [Node<'n>]) -> Context<'n> {
-        let mut extends = None;
-        let mut blocks = Vec::new();
-        let mut macros = HashMap::new();
-        let mut imports = HashMap::new();
-
-        for n in nodes {
-            match n {
-                Node::Extends(Expr::StrLit(extends_path)) => match extends {
-                    Some(_) => panic!("multiple extend blocks found"),
-                    None => {
-                        extends = Some(config.find_template(extends_path, Some(path)));
-                    }
-                },
-                def @ Node::BlockDef(_, _, _, _) => {
-                    blocks.push(def);
-                }
-                Node::Macro(name, m) => {
-                    macros.insert(*name, m);
-                }
-                Node::Import(_, import_path, scope) => {
-                    let path = config.find_template(import_path, Some(path));
-                    imports.insert(*scope, path);
-                }
-                _ => {}
-            }
-        }
-
-        let mut check_nested = 0;
-        let mut nested_blocks = Vec::new();
-        while check_nested < blocks.len() {
-            if let Node::BlockDef(_, _, ref nodes, _) = blocks[check_nested] {
-                for n in nodes {
-                    if let def @ Node::BlockDef(_, _, _, _) = n {
-                        nested_blocks.push(def);
-                    }
-                }
-            } else {
-                panic!("non block found in list of blocks");
-            }
-            blocks.append(&mut nested_blocks);
-            check_nested += 1;
-        }
-
-        let blocks: HashMap<_, _> = blocks
-            .iter()
-            .map(|def| {
-                if let Node::BlockDef(_, name, _, _) = def {
-                    (*name, *def)
-                } else {
-                    unreachable!()
-                }
-            })
-            .collect();
-
-        Context {
-            nodes,
-            extends,
-            blocks,
-            macros,
-            imports,
-        }
-    }
-}
-
-#[allow(clippy::match_wild_err_arm)]
-fn get_template_source(tpl_path: &Path) -> String {
-    match fs::read_to_string(tpl_path) {
-        Err(_) => panic!(
-            "unable to open template file '{}'",
-            tpl_path.to_str().unwrap()
-        ),
-        Ok(mut source) => {
-            if source.ends_with('\n') {
-                let _ = source.pop();
-            }
-            source
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::get_template_source;
-    use crate::Config;
-
-    #[test]
-    fn get_source() {
-        let path = Config::new("").find_template("b.html", None);
-        assert_eq!(get_template_source(&path), "bar");
-    }
-}
+const INTEGRATIONS: Integrations = Integrations {
+    actix: cfg!(feature = "actix-web"),
+    gotham: cfg!(feature = "gotham"),
+    iron: cfg!(feature = "iron"),
+    rocket: cfg!(feature = "rocket"),
+    warp: cfg!(feature = "warp"),
+};