Improve error handling (see #368)

5 files changed, 554 insertions, 418 deletions

diff --git a/askama_shared/src/generator.rs b/askama_shared/src/generator.rs
index a82714b..cbf0d1a 100644
--- a/askama_shared/src/generator.rs
+++ b/askama_shared/src/generator.rs
@@ -1,4 +1,4 @@
-use super::{get_template_source, Integrations};
+use super::{get_template_source, CompileError, Integrations};
 use crate::filters;
 use crate::heritage::{Context, Heritage};
 use crate::input::{Source, TemplateInput};
@@ -19,7 +19,7 @@ pub fn generate<S: std::hash::BuildHasher>(
     contexts: &HashMap<&PathBuf, Context, S>,
     heritage: &Option<Heritage>,
     integrations: Integrations,
-) -> String {
+) -> Result<String, CompileError> {
     Generator::new(input, contexts, heritage, integrations, SetChain::new())
         .build(&contexts[&input.path])
 }
@@ -84,48 +84,48 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
     }
 
     // Takes a Context and generates the relevant implementations.
-    fn build(mut self, ctx: &'a Context) -> String {
+    fn build(mut self, ctx: &'a Context) -> Result<String, CompileError> {
         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.deref_to_parent(&mut buf, parent)?;
             }
         };
 
-        self.impl_template(ctx, &mut buf);
-        self.impl_display(&mut buf);
+        self.impl_template(ctx, &mut buf)?;
+        self.impl_display(&mut buf)?;
 
         if self.integrations.actix {
-            self.impl_actix_web_responder(&mut buf);
+            self.impl_actix_web_responder(&mut buf)?;
         }
         if self.integrations.gotham {
-            self.impl_gotham_into_response(&mut buf);
+            self.impl_gotham_into_response(&mut buf)?;
         }
         if self.integrations.iron {
-            self.impl_iron_modifier_response(&mut buf);
+            self.impl_iron_modifier_response(&mut buf)?;
         }
         if self.integrations.mendes {
-            self.impl_mendes_responder(&mut buf);
+            self.impl_mendes_responder(&mut buf)?;
         }
         if self.integrations.rocket {
-            self.impl_rocket_responder(&mut buf);
+            self.impl_rocket_responder(&mut buf)?;
         }
         if self.integrations.tide {
-            self.impl_tide_integrations(&mut buf);
+            self.impl_tide_integrations(&mut buf)?;
         }
         if self.integrations.warp {
-            self.impl_warp_reply(&mut buf);
+            self.impl_warp_reply(&mut buf)?;
         }
-        buf.buf
+        Ok(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);
+    fn impl_template(&mut self, ctx: &'a Context, buf: &mut Buffer) -> Result<(), CompileError> {
+        self.write_header(buf, "::askama::Template", None)?;
         buf.writeln(
             "fn render_into(&self, writer: &mut dyn ::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() {
@@ -141,7 +141,7 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
                         include_bytes!(#path);
                     }
                     .to_string(),
-                );
+                )?;
             }
         }
 
@@ -149,107 +149,112 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
             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("Ok(())")?;
+        buf.writeln("}")?;
 
-        buf.writeln("fn extension(&self) -> Option<&'static str> {");
+        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("}")?;
 
-        buf.writeln("fn size_hint(&self) -> usize {");
-        buf.writeln(&format!("{}", size_hint));
-        buf.writeln("}");
+        buf.writeln("fn size_hint(&self) -> usize {")?;
+        buf.writeln(&format!("{}", size_hint))?;
+        buf.writeln("}")?;
 
-        buf.writeln("}");
+        buf.writeln("}")?;
 
-        self.write_header(buf, "::askama::SizedTemplate", None);
+        self.write_header(buf, "::askama::SizedTemplate", None)?;
 
-        buf.writeln("fn size_hint() -> usize {");
-        buf.writeln(&format!("{}", size_hint));
-        buf.writeln("}");
+        buf.writeln("fn size_hint() -> usize {")?;
+        buf.writeln(&format!("{}", size_hint))?;
+        buf.writeln("}")?;
 
-        buf.writeln("fn extension() -> Option<&'static str> {");
+        buf.writeln("fn extension() -> Option<&'static str> {")?;
         buf.writeln(&format!(
             "{:?}",
             self.input.path.extension().map(|s| s.to_str().unwrap())
-        ));
-        buf.writeln("}");
+        ))?;
+        buf.writeln("}")?;
 
-        buf.writeln("}");
+        buf.writeln("}")?;
+        Ok(())
     }
 
     // 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);
+    fn deref_to_parent(
+        &mut self,
+        buf: &mut Buffer,
+        parent_type: &syn::Type,
+    ) -> Result<(), CompileError> {
+        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("}");
+        ))?;
+        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("}");
+    fn impl_display(&mut self, buf: &mut Buffer) -> Result<(), CompileError> {
+        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 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 = ::askama_actix::futures::Ready<::std::result::Result<::actix_web::HttpResponse, Self::Error>>;");
-        buf.writeln("type Error = ::actix_web::Error;");
+    fn impl_actix_web_responder(&mut self, buf: &mut Buffer) -> Result<(), CompileError> {
+        self.write_header(buf, "::actix_web::Responder", None)?;
+        buf.writeln("type Future = ::askama_actix::futures::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("::askama_actix::futures::ready(self.into_response())");
+        buf.writeln("use ::askama_actix::TemplateIntoResponse;")?;
+        buf.writeln("::askama_actix::futures::ready(self.into_response())")?;
 
-        buf.writeln("}");
-        buf.writeln("}");
+        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);
+    fn impl_gotham_into_response(&mut self, buf: &mut Buffer) -> Result<(), CompileError> {
+        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("}");
+        buf.writeln(&format!("::askama_gotham::respond(&self, {:?})", ext))?;
+        buf.writeln("}")?;
+        buf.writeln("}")
     }
 
     // Implement iron's Modifier<Response> if enabled
-    fn impl_iron_modifier_response(&mut self, buf: &mut Buffer) {
+    fn impl_iron_modifier_response(&mut self, buf: &mut Buffer) -> Result<(), CompileError> {
         self.write_header(
             buf,
             "::askama_iron::Modifier<::askama_iron::Response>",
             None,
-        );
-        buf.writeln("fn modify(self, res: &mut ::askama_iron::Response) {");
+        )?;
+        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
@@ -258,17 +263,17 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
             .map_or("", |s| s.to_str().unwrap_or(""));
         match ext {
             "html" | "htm" => {
-                buf.writeln("::askama_iron::ContentType::html().0.modify(res);");
+                buf.writeln("::askama_iron::ContentType::html().0.modify(res);")?;
             }
             _ => (),
         };
 
-        buf.writeln("}");
-        buf.writeln("}");
+        buf.writeln("}")?;
+        buf.writeln("}")
     }
 
     // Implement mendes' `Responder`.
-    fn impl_mendes_responder(&mut self, buf: &mut Buffer) {
+    fn impl_mendes_responder(&mut self, buf: &mut Buffer) -> Result<(), CompileError> {
         let param = syn::parse_str("A: ::mendes::Application").unwrap();
 
         let mut generics = self.input.ast.generics.clone();
@@ -300,46 +305,48 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
                 quote!(#orig_ty_generics #where_clause),
             )
             .as_ref(),
-        );
+        )?;
 
         buf.writeln(
             "fn into_response(self, app: &A) \
              -> ::mendes::http::Response<A::ResponseBody> {",
-        );
+        )?;
 
         buf.writeln(&format!(
             "::mendes::askama::into_response(app, &self, {:?})",
             self.input.path.extension()
-        ));
-        buf.writeln("}");
-        buf.writeln("}");
+        ))?;
+        buf.writeln("}")?;
+        buf.writeln("}")?;
+        Ok(())
     }
 
     // Implement Rocket's `Responder`.
-    fn impl_rocket_responder(&mut self, buf: &mut Buffer) {
+    fn impl_rocket_responder(&mut self, buf: &mut Buffer) -> Result<(), CompileError> {
         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(&format!("::askama_rocket::respond(&self, {:?})", ext))?;
 
-        buf.writeln("}");
-        buf.writeln("}");
+        buf.writeln("}")?;
+        buf.writeln("}")?;
+        Ok(())
     }
 
-    fn impl_tide_integrations(&mut self, buf: &mut Buffer) {
+    fn impl_tide_integrations(&mut self, buf: &mut Buffer) -> Result<(), CompileError> {
         let ext = self
             .input
             .path
@@ -351,32 +358,32 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
             buf,
             "std::convert::TryInto<::askama_tide::tide::Body>",
             None,
-        );
+        )?;
         buf.writeln(
             "type Error = ::askama_tide::askama::Error;\n\
             fn try_into(self) -> ::askama_tide::askama::Result<::askama_tide::tide::Body> {",
-        );
-        buf.writeln(&format!("::askama_tide::try_into_body(&self, {:?})", &ext));
-        buf.writeln("}");
-        buf.writeln("}");
-        self.write_header(buf, "Into<::askama_tide::tide::Response>", None);
-        buf.writeln("fn into(self) -> ::askama_tide::tide::Response {");
-        buf.writeln(&format!("::askama_tide::into_response(&self, {:?})", ext));
-        buf.writeln("}\n}");
-    }
-
-    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 {");
+        )?;
+        buf.writeln(&format!("::askama_tide::try_into_body(&self, {:?})", &ext))?;
+        buf.writeln("}")?;
+        buf.writeln("}")?;
+        self.write_header(buf, "Into<::askama_tide::tide::Response>", None)?;
+        buf.writeln("fn into(self) -> ::askama_tide::tide::Response {")?;
+        buf.writeln(&format!("::askama_tide::into_response(&self, {:?})", ext))?;
+        buf.writeln("}\n}")
+    }
+
+    fn impl_warp_reply(&mut self, buf: &mut Buffer) -> Result<(), CompileError> {
+        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("}");
+        buf.writeln(&format!("::askama_warp::reply(&self, {:?})", ext))?;
+        buf.writeln("}")?;
+        buf.writeln("}")
     }
 
     // Writes header for the `impl` for `TraitFromPathName` or `Template`
@@ -386,7 +393,7 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
         buf: &mut Buffer,
         target: &str,
         params: Option<Vec<syn::GenericParam>>,
-    ) {
+    ) -> Result<(), CompileError> {
         let mut generics = self.input.ast.generics.clone();
         if let Some(params) = params {
             for param in params {
@@ -404,7 +411,7 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
                 quote!(#orig_ty_generics #where_clause),
             )
             .as_ref(),
-        );
+        )
     }
 
     /* Helper methods for handling node types */
@@ -415,7 +422,7 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
         nodes: &'a [Node],
         buf: &mut Buffer,
         level: AstLevel,
-    ) -> usize {
+    ) -> Result<usize, CompileError> {
         let mut size_hint = 0;
         for n in nodes {
             match *n {
@@ -429,32 +436,32 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
                     self.write_expr(ws, val);
                 }
                 Node::LetDecl(ws, ref var) => {
-                    self.write_let_decl(buf, ws, var);
+                    self.write_let_decl(buf, ws, var)?;
                 }
                 Node::Let(ws, ref var, ref val) => {
-                    self.write_let(buf, ws, var, val);
+                    self.write_let(buf, ws, var, val)?;
                 }
                 Node::Cond(ref conds, ws) => {
-                    self.write_cond(ctx, buf, 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);
+                    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);
+                    self.write_loop(ctx, buf, ws1, var, iter, body, ws2)?;
                 }
                 Node::BlockDef(ws1, name, _, ws2) => {
-                    self.write_block(buf, Some(name), WS(ws1.0, ws2.1));
+                    self.write_block(buf, Some(name), WS(ws1.0, ws2.1))?;
                 }
                 Node::Include(ws, path) => {
-                    size_hint += self.handle_include(ctx, buf, 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);
+                    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");
+                        return Err("macro blocks only allowed at the top level".into());
                     }
                     self.flush_ws(m.ws1);
                     self.prepare_ws(m.ws2);
@@ -466,13 +473,13 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
                 }
                 Node::Import(ws, _, _) => {
                     if level != AstLevel::Top {
-                        panic!("import blocks only allowed at the top level");
+                        return Err("import blocks only allowed at the top level".into());
                     }
                     self.handle_ws(ws);
                 }
                 Node::Extends(_) => {
                     if level != AstLevel::Top {
-                        panic!("extend blocks only allowed at the top level");
+                        return Err("extend blocks only allowed at the top level".into());
                     }
                     // No whitespace handling: child template top-level is not used,
                     // except for the blocks defined in it.
@@ -481,9 +488,9 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
         }
 
         if AstLevel::Top == level {
-            size_hint += self.write_buf_writable(buf);
+            size_hint += self.write_buf_writable(buf)?;
         }
-        size_hint
+        Ok(size_hint)
     }
 
     fn write_cond(
@@ -492,14 +499,14 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
         buf: &mut Buffer,
         conds: &'a [Cond],
         ws: WS,
-    ) -> usize {
+    ) -> Result<usize, CompileError> {
         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);
+                flushed += self.write_buf_writable(buf)?;
             }
 
             let mut arm_size = 0;
@@ -508,35 +515,35 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
                     if i == 0 {
                         buf.write("if ");
                     } else {
-                        buf.dedent();
+                        buf.dedent()?;
                         buf.write("} else if ");
                     }
-                    let expr_code = self.visit_expr_root(expr);
+                    let expr_code = self.visit_expr_root(expr)?;
                     buf.write(&expr_code);
                 }
                 None => {
-                    buf.dedent();
+                    buf.dedent()?;
                     buf.write("} else");
                     has_else = true;
                 }
             }
 
-            buf.writeln(" {");
+            buf.writeln(" {")?;
             self.locals.push();
 
-            arm_size += self.handle(ctx, nodes, buf, AstLevel::Nested);
-            arm_size += self.write_buf_writable(buf);
+            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("}");
+        buf.writeln("}")?;
 
         if !has_else {
             arm_sizes.push(0);
         }
-        flushed + median(&mut arm_sizes)
+        Ok(flushed + median(&mut arm_sizes))
     }
 
     #[allow(clippy::too_many_arguments)]
@@ -549,9 +556,9 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
         inter: Option<&'a str>,
         arms: &'a [When],
         ws2: WS,
-    ) -> usize {
+    ) -> Result<usize, CompileError> {
         self.flush_ws(ws1);
-        let flushed = self.write_buf_writable(buf);
+        let flushed = self.write_buf_writable(buf)?;
         let mut arm_sizes = Vec::new();
         if let Some(inter) = inter {
             if !inter.is_empty() {
@@ -559,8 +566,8 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
             }
         }
 
-        let expr_code = self.visit_expr_root(expr);
-        buf.writeln(&format!("match &{} {{", expr_code));
+        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();
@@ -608,17 +615,17 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
                     buf.write("}");
                 }
             }
-            buf.writeln(" => {");
+            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("}");
+            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("}");
+        buf.writeln("}")?;
         self.handle_ws(ws2);
-        flushed + median(&mut arm_sizes)
+        Ok(flushed + median(&mut arm_sizes))
     }
 
     #[allow(clippy::too_many_arguments)]
@@ -631,13 +638,13 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
         iter: &Expr,
         body: &'a [Node],
         ws2: WS,
-    ) -> usize {
+    ) -> Result<usize, CompileError> {
         self.handle_ws(ws1);
         self.locals.push();
 
-        let expr_code = self.visit_expr_root(iter);
+        let expr_code = self.visit_expr_root(iter)?;
 
-        let flushed = self.write_buf_writable(buf);
+        let flushed = self.write_buf_writable(buf)?;
         buf.write("for (");
         self.visit_target(buf, var);
         match iter {
@@ -649,15 +656,15 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
                 ", _loop_item) in ::askama::helpers::TemplateLoop::new((&{}).into_iter()) {{",
                 expr_code
             )),
-        };
+        }?;
 
-        let mut size_hint = self.handle(ctx, body, buf, AstLevel::Nested);
+        let mut size_hint = self.handle(ctx, body, buf, AstLevel::Nested)?;
         self.handle_ws(ws2);
 
-        size_hint += self.write_buf_writable(buf);
-        buf.writeln("}");
+        size_hint += self.write_buf_writable(buf)?;
+        buf.writeln("}")?;
         self.locals.pop();
-        flushed + (size_hint * 3)
+        Ok(flushed + (size_hint * 3))
     }
 
     fn write_call(
@@ -668,69 +675,72 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
         scope: Option<&str>,
         name: &str,
         args: &[Expr],
-    ) -> usize {
+    ) -> Result<usize, CompileError> {
         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));
+            let path = ctx.imports.get(s).ok_or_else(|| {
+                CompileError::String(format!("no import found for scope '{}'", s))
+            })?;
+            let mctx = self.contexts.get(path).ok_or_else(|| {
+                CompileError::String(format!("context for '{:?}' not found", path))
+            })?;
             (
-                mctx.macros
-                    .get(name)
-                    .unwrap_or_else(|| panic!("macro '{}' not found in scope '{}'", s, name)),
+                mctx.macros.get(name).ok_or_else(|| {
+                    CompileError::String(format!("macro '{}' not found in scope '{}'", s, name))
+                })?,
                 mctx,
             )
         } else {
             (
                 ctx.macros
                     .get(name)
-                    .unwrap_or_else(|| panic!("macro '{}' not found", name)),
+                    .ok_or_else(|| CompileError::String(format!("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.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));
+            let expr_code = self.visit_expr_root(args.get(i).ok_or_else(|| {
+                CompileError::String(format!("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);
+        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("}");
+        size_hint += self.write_buf_writable(buf)?;
+        buf.writeln("}")?;
         self.locals.pop();
         self.prepare_ws(ws);
-        size_hint
+        Ok(size_hint)
     }
 
-    fn handle_include(&mut self, ctx: &'a Context, buf: &mut Buffer, ws: WS, path: &str) -> usize {
+    fn handle_include(
+        &mut self,
+        ctx: &'a Context,
+        buf: &mut Buffer,
+        ws: WS,
+        path: &str,
+    ) -> Result<usize, CompileError> {
         self.flush_ws(ws);
-        self.write_buf_writable(buf);
+        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);
+            .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.
         {
@@ -740,24 +750,29 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
                     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);
+            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
+        Ok(size_hint)
     }
 
-    fn write_let_decl(&mut self, buf: &mut Buffer, ws: WS, var: &'a Target) {
+    fn write_let_decl(
+        &mut self,
+        buf: &mut Buffer,
+        ws: WS,
+        var: &'a Target,
+    ) -> Result<(), CompileError> {
         self.handle_ws(ws);
-        self.write_buf_writable(buf);
+        self.write_buf_writable(buf)?;
         buf.write("let ");
         match *var {
             Target::Name(name) => {
@@ -774,13 +789,19 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
                 buf.write(")");
             }
         }
-        buf.writeln(";");
+        buf.writeln(";")
     }
 
-    fn write_let(&mut self, buf: &mut Buffer, ws: WS, var: &'a Target, val: &Expr) {
+    fn write_let(
+        &mut self,
+        buf: &mut Buffer,
+        ws: WS,
+        var: &'a Target,
+        val: &Expr,
+    ) -> Result<(), CompileError> {
         self.handle_ws(ws);
         let mut expr_buf = Buffer::new(0);
-        self.visit_expr(&mut expr_buf, val);
+        self.visit_expr(&mut expr_buf, val)?;
 
         match *var {
             Target::Name(name) => {
@@ -800,13 +821,18 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
                 buf.write(")");
             }
         }
-        buf.writeln(&format!(" = {};", &expr_buf.buf));
+        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 {
+    fn write_block(
+        &mut self,
+        buf: &mut Buffer,
+        name: Option<&'a str>,
+        outer: WS,
+    ) -> Result<usize, CompileError> {
         // Flush preceding whitespace according to the outer WS spec
         self.flush_ws(outer);
 
@@ -816,14 +842,14 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
             (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)
+                return Err(format!("cannot define recursive blocks ({})", cur_name).into());
             }
             // 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"),
+            (None, None) => return Err("cannot call 'super()' outside block".into()),
         };
         self.super_block = Some(cur);
 
@@ -831,13 +857,13 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
         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),
-            });
+            .ok_or(CompileError::Static("no block ancestors available"))?;
+        let (ctx, def) = heritage.blocks[cur.0].get(cur.1).ok_or_else(|| {
+            CompileError::from(match name {
+                None => format!("no super() block found for block '{}'", cur.0),
+                Some(name) => format!("no block found for name '{}'", name),
+            })
+        })?;
 
         // Get the nodes and whitespace suppression data from the block definition
         let (ws1, nodes, ws2) = if let Node::BlockDef(ws1, _, nodes, ws2) = def {
@@ -849,11 +875,11 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
         // 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);
+        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.write_buf_writable(buf)?;
         }
 
         self.locals.pop();
@@ -863,7 +889,7 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
         // succeeding whitespace according to the outer WS spec
         self.super_block = prev_block;
         self.prepare_ws(outer);
-        size_hint
+        Ok(size_hint)
     }
 
     fn write_expr(&mut self, ws: WS, s: &'a Expr<'a>) {
@@ -872,9 +898,9 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
     }
 
     // Write expression buffer and empty
-    fn write_buf_writable(&mut self, buf: &mut Buffer) -> usize {
+    fn write_buf_writable(&mut self, buf: &mut Buffer) -> Result<usize, CompileError> {
         if self.buf_writable.is_empty() {
-            return 0;
+            return Ok(0);
         }
 
         if self
@@ -888,8 +914,8 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
                     buf_lit.write(s);
                 };
             }
-            buf.writeln(&format!("writer.write_str({:#?})?;", &buf_lit.buf));
-            return buf_lit.buf.len();
+            buf.writeln(&format!("writer.write_str({:#?})?;", &buf_lit.buf))?;
+            return Ok(buf_lit.buf.len());
         }
 
         let mut size_hint = 0;
@@ -905,7 +931,7 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
                 Writable::Expr(s) => {
                     use self::DisplayWrap::*;
                     let mut expr_buf = Buffer::new(0);
-                    let wrapped = self.visit_expr(&mut expr_buf, s);
+                    let wrapped = self.visit_expr(&mut expr_buf, s)?;
                     let expression = match wrapped {
                         Wrapped => expr_buf.buf,
                         Unwrapped => format!(
@@ -914,17 +940,22 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
                         ),
                     };
 
-                    let id = expr_cache.entry(expression.clone()).or_insert_with(|| {
-                        let id = self.named;
-                        self.named += 1;
+                    use std::collections::hash_map::Entry;
+                    let id = match expr_cache.entry(expression.clone()) {
+                        Entry::Occupied(e) => *e.get(),
+                        Entry::Vacant(e) => {
+                            let id = self.named;
+                            self.named += 1;
 
-                        buf_expr.write(&format!("expr{} = ", id));
-                        buf_expr.write("&");
-                        buf_expr.write(&expression);
-                        buf_expr.writeln(",");
+                            buf_expr.write(&format!("expr{} = ", id));
+                            buf_expr.write("&");
+                            buf_expr.write(&expression);
+                            buf_expr.writeln(",")?;
 
-                        id
-                    });
+                            e.insert(id);
+                            id
+                        }
+                    };
 
                     buf_format.write(&format!("{{expr{}}}", id));
                     size_hint += 3;
@@ -932,14 +963,14 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
             }
         }
 
-        buf.writeln("write!(");
+        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
+        buf.writeln("writer,")?;
+        buf.writeln(&format!("{:#?},", &buf_format.buf))?;
+        buf.writeln(buf_expr.buf.trim())?;
+        buf.dedent()?;
+        buf.writeln(")?;")?;
+        Ok(size_hint)
     }
 
     fn visit_lit(&mut self, lws: &'a str, val: &'a str, rws: &'a str) {
@@ -970,35 +1001,35 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
 
     /* Visitor methods for expression types */
 
-    fn visit_expr_root(&mut self, expr: &Expr) -> String {
+    fn visit_expr_root(&mut self, expr: &Expr) -> Result<String, CompileError> {
         let mut buf = Buffer::new(0);
-        self.visit_expr(&mut buf, expr);
-        buf.buf
+        self.visit_expr(&mut buf, expr)?;
+        Ok(buf.buf)
     }
 
-    fn visit_expr(&mut self, buf: &mut Buffer, expr: &Expr) -> DisplayWrap {
-        match *expr {
+    fn visit_expr(&mut self, buf: &mut Buffer, expr: &Expr) -> Result<DisplayWrap, CompileError> {
+        Ok(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::VarCall(var, ref args) => self.visit_var_call(buf, var, args),
+            Expr::VarCall(var, ref args) => self.visit_var_call(buf, var, args)?,
             Expr::Path(ref path) => self.visit_path(buf, path),
-            Expr::PathCall(ref path, ref args) => self.visit_path_call(buf, path, args),
-            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::PathCall(ref path, ref args) => self.visit_path_call(buf, path, args)?,
+            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)
+                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 {
@@ -1047,16 +1078,21 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
         wrapped
     }
 
-    fn visit_filter(&mut self, buf: &mut Buffer, name: &str, args: &[Expr]) -> DisplayWrap {
+    fn visit_filter(
+        &mut self,
+        buf: &mut Buffer,
+        name: &str,
+        args: &[Expr],
+    ) -> Result<DisplayWrap, CompileError> {
         if name == "format" {
-            self._visit_format_filter(buf, args);
-            return DisplayWrap::Unwrapped;
+            self._visit_format_filter(buf, args)?;
+            return Ok(DisplayWrap::Unwrapped);
         } else if name == "fmt" {
-            self._visit_fmt_filter(buf, args);
-            return DisplayWrap::Unwrapped;
+            self._visit_fmt_filter(buf, args)?;
+            return Ok(DisplayWrap::Unwrapped);
         } else if name == "join" {
-            self._visit_join_filter(buf, args);
-            return DisplayWrap::Unwrapped;
+            self._visit_join_filter(buf, args)?;
+            return Ok(DisplayWrap::Unwrapped);
         }
 
         if name == "escape" || name == "safe" || name == "e" || name == "json" {
@@ -1070,16 +1106,22 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
             buf.write(&format!("filters::{}(", name));
         }
 
-        self._visit_args(buf, args);
+        self._visit_args(buf, args)?;
         buf.write(")?");
-        if name == "safe" || name == "escape" || name == "e" || name == "json" {
-            DisplayWrap::Wrapped
-        } else {
-            DisplayWrap::Unwrapped
-        }
+        Ok(
+            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]) {
+    fn _visit_format_filter(
+        &mut self,
+        buf: &mut Buffer,
+        args: &[Expr],
+    ) -> Result<(), CompileError> {
         buf.write("format!(");
         if let Some(Expr::StrLit(v)) = args.first() {
             self.visit_str_lit(buf, v);
@@ -1087,45 +1129,48 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
                 buf.write(", ");
             }
         } else {
-            panic!("invalid expression type for format filter");
+            return Err("invalid expression type for format filter".into());
         }
-        self._visit_args(buf, &args[1..]);
+        self._visit_args(buf, &args[1..])?;
         buf.write(")");
+        Ok(())
     }
 
-    fn _visit_fmt_filter(&mut self, buf: &mut Buffer, args: &[Expr]) {
+    fn _visit_fmt_filter(&mut self, buf: &mut Buffer, args: &[Expr]) -> Result<(), CompileError> {
         buf.write("format!(");
         if let Some(Expr::StrLit(v)) = args.get(1) {
             self.visit_str_lit(buf, v);
             buf.write(", ");
         } else {
-            panic!("invalid expression type for fmt filter");
+            return Err("invalid expression type for fmt filter".into());
         }
-        self._visit_args(buf, &args[0..1]);
+        self._visit_args(buf, &args[0..1])?;
         if args.len() > 2 {
-            panic!("only two arguments allowed to fmt filter");
+            return Err("only two arguments allowed to fmt filter".into());
         }
         buf.write(")");
+        Ok(())
     }
 
     // Force type coercion on first argument to `join` filter (see #39).
-    fn _visit_join_filter(&mut self, buf: &mut Buffer, args: &[Expr]) {
+    fn _visit_join_filter(&mut self, buf: &mut Buffer, args: &[Expr]) -> Result<(), CompileError> {
         buf.write("::askama::filters::join((&");
         for (i, arg) in args.iter().enumerate() {
             if i > 0 {
                 buf.write(", &");
             }
-            self.visit_expr(buf, arg);
+            self.visit_expr(buf, arg)?;
             if i == 0 {
                 buf.write(").into_iter()");
             }
         }
         buf.write(")?");
+        Ok(())
     }
 
-    fn _visit_args(&mut self, buf: &mut Buffer, args: &[Expr]) {
+    fn _visit_args(&mut self, buf: &mut Buffer, args: &[Expr]) -> Result<(), CompileError> {
         if args.is_empty() {
-            return;
+            return Ok(());
         }
 
         for (i, arg) in args.iter().enumerate() {
@@ -1142,47 +1187,58 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
                 | Expr::PathCall(_, _));
 
             if scoped {
-                buf.writeln("{");
-                self.visit_expr(buf, arg);
-                buf.writeln("}");
+                buf.writeln("{")?;
+                self.visit_expr(buf, arg)?;
+                buf.writeln("}")?;
             } else {
-                self.visit_expr(buf, arg);
+                self.visit_expr(buf, arg)?;
             }
         }
+        Ok(())
     }
 
-    fn visit_attr(&mut self, buf: &mut Buffer, obj: &Expr, attr: &str) -> DisplayWrap {
+    fn visit_attr(
+        &mut self,
+        buf: &mut Buffer,
+        obj: &Expr,
+        attr: &str,
+    ) -> Result<DisplayWrap, CompileError> {
         if let Expr::Var(name) = *obj {
             if name == "loop" {
                 if attr == "index" {
                     buf.write("(_loop_item.index + 1)");
-                    return DisplayWrap::Unwrapped;
+                    return Ok(DisplayWrap::Unwrapped);
                 } else if attr == "index0" {
                     buf.write("_loop_item.index");
-                    return DisplayWrap::Unwrapped;
+                    return Ok(DisplayWrap::Unwrapped);
                 } else if attr == "first" {
                     buf.write("_loop_item.first");
-                    return DisplayWrap::Unwrapped;
+                    return Ok(DisplayWrap::Unwrapped);
                 } else if attr == "last" {
                     buf.write("_loop_item.last");
-                    return DisplayWrap::Unwrapped;
+                    return Ok(DisplayWrap::Unwrapped);
                 } else {
-                    panic!("unknown loop variable");
+                    return Err("unknown loop variable".into());
                 }
             }
         }
-        self.visit_expr(buf, obj);
+        self.visit_expr(buf, obj)?;
         buf.write(&format!(".{}", attr));
-        DisplayWrap::Unwrapped
+        Ok(DisplayWrap::Unwrapped)
     }
 
-    fn visit_index(&mut self, buf: &mut Buffer, obj: &Expr, key: &Expr) -> DisplayWrap {
+    fn visit_index(
+        &mut self,
+        buf: &mut Buffer,
+        obj: &Expr,
+        key: &Expr,
+    ) -> Result<DisplayWrap, CompileError> {
         buf.write("&");
-        self.visit_expr(buf, obj);
+        self.visit_expr(buf, obj)?;
         buf.write("[");
-        self.visit_expr(buf, key);
+        self.visit_expr(buf, key)?;
         buf.write("]");
-        DisplayWrap::Unwrapped
+        Ok(DisplayWrap::Unwrapped)
     }
 
     fn visit_method_call(
@@ -1191,23 +1247,28 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
         obj: &Expr,
         method: &str,
         args: &[Expr],
-    ) -> DisplayWrap {
+    ) -> Result<DisplayWrap, CompileError> {
         if let Expr::Var("self") = obj {
             buf.write("self");
         } else {
-            self.visit_expr(buf, obj);
+            self.visit_expr(buf, obj)?;
         }
 
         buf.write(&format!(".{}(", method));
-        self._visit_args(buf, args);
+        self._visit_args(buf, args)?;
         buf.write(")");
-        DisplayWrap::Unwrapped
+        Ok(DisplayWrap::Unwrapped)
     }
 
-    fn visit_unary(&mut self, buf: &mut Buffer, op: &str, inner: &Expr) -> DisplayWrap {
+    fn visit_unary(
+        &mut self,
+        buf: &mut Buffer,
+        op: &str,
+        inner: &Expr,
+    ) -> Result<DisplayWrap, CompileError> {
         buf.write(op);
-        self.visit_expr(buf, inner);
-        DisplayWrap::Unwrapped
+        self.visit_expr(buf, inner)?;
+        Ok(DisplayWrap::Unwrapped)
     }
 
     fn visit_range(
@@ -1216,15 +1277,15 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
         op: &str,
         left: &Option<Box<Expr>>,
         right: &Option<Box<Expr>>,
-    ) -> DisplayWrap {
+    ) -> Result<DisplayWrap, CompileError> {
         if let Some(left) = left {
-            self.visit_expr(buf, left);
+            self.visit_expr(buf, left)?;
         }
         buf.write(op);
         if let Some(right) = right {
-            self.visit_expr(buf, right);
+            self.visit_expr(buf, right)?;
         }
-        DisplayWrap::Unwrapped
+        Ok(DisplayWrap::Unwrapped)
     }
 
     fn visit_binop(
@@ -1233,30 +1294,34 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
         op: &str,
         left: &Expr,
         right: &Expr,
-    ) -> DisplayWrap {
-        self.visit_expr(buf, left);
+    ) -> Result<DisplayWrap, CompileError> {
+        self.visit_expr(buf, left)?;
         buf.write(&format!(" {} ", op));
-        self.visit_expr(buf, right);
-        DisplayWrap::Unwrapped
+        self.visit_expr(buf, right)?;
+        Ok(DisplayWrap::Unwrapped)
     }
 
-    fn visit_group(&mut self, buf: &mut Buffer, inner: &Expr) -> DisplayWrap {
+    fn visit_group(&mut self, buf: &mut Buffer, inner: &Expr) -> Result<DisplayWrap, CompileError> {
         buf.write("(");
-        self.visit_expr(buf, inner);
+        self.visit_expr(buf, inner)?;
         buf.write(")");
-        DisplayWrap::Unwrapped
+        Ok(DisplayWrap::Unwrapped)
     }
 
-    fn visit_array(&mut self, buf: &mut Buffer, elements: &[Expr]) -> DisplayWrap {
+    fn visit_array(
+        &mut self,
+        buf: &mut Buffer,
+        elements: &[Expr],
+    ) -> Result<DisplayWrap, CompileError> {
         buf.write("[");
         for (i, el) in elements.iter().enumerate() {
             if i > 0 {
                 buf.write(", ");
             }
-            self.visit_expr(buf, el);
+            self.visit_expr(buf, el)?;
         }
         buf.write("]");
-        DisplayWrap::Unwrapped
+        Ok(DisplayWrap::Unwrapped)
     }
 
     fn visit_path(&mut self, buf: &mut Buffer, path: &[&str]) -> DisplayWrap {
@@ -1269,7 +1334,12 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
         DisplayWrap::Unwrapped
     }
 
-    fn visit_path_call(&mut self, buf: &mut Buffer, path: &[&str], args: &[Expr]) -> DisplayWrap {
+    fn visit_path_call(
+        &mut self,
+        buf: &mut Buffer,
+        path: &[&str],
+        args: &[Expr],
+    ) -> Result<DisplayWrap, CompileError> {
         for (i, part) in path.iter().enumerate() {
             if i > 0 {
                 buf.write("::");
@@ -1277,9 +1347,9 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
             buf.write(part);
         }
         buf.write("(");
-        self._visit_args(buf, args);
+        self._visit_args(buf, args)?;
         buf.write(")");
-        DisplayWrap::Unwrapped
+        Ok(DisplayWrap::Unwrapped)
     }
 
     fn visit_var(&mut self, buf: &mut Buffer, s: &str) -> DisplayWrap {
@@ -1292,7 +1362,12 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
         DisplayWrap::Unwrapped
     }
 
-    fn visit_var_call(&mut self, buf: &mut Buffer, s: &str, args: &[Expr]) -> DisplayWrap {
+    fn visit_var_call(
+        &mut self,
+        buf: &mut Buffer,
+        s: &str,
+        args: &[Expr],
+    ) -> Result<DisplayWrap, CompileError> {
         buf.write("(");
         if self.locals.contains(s) || s == "self" {
             buf.write(s);
@@ -1301,9 +1376,9 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
             buf.write(s);
         }
         buf.write(")(");
-        self._visit_args(buf, args);
+        self._visit_args(buf, args)?;
         buf.write(")");
-        DisplayWrap::Unwrapped
+        Ok(DisplayWrap::Unwrapped)
     }
 
     fn visit_bool_lit(&mut self, buf: &mut Buffer, s: &str) -> DisplayWrap {
@@ -1392,9 +1467,9 @@ impl Buffer {
         }
     }
 
-    fn writeln(&mut self, s: &str) {
+    fn writeln(&mut self, s: &str) -> Result<(), CompileError> {
         if s == "}" {
-            self.dedent();
+            self.dedent()?;
         }
         if !s.is_empty() {
             self.write(s);
@@ -1404,6 +1479,7 @@ impl Buffer {
             self.indent();
         }
         self.start = true;
+        Ok(())
     }
 
     fn write(&mut self, s: &str) {
@@ -1420,11 +1496,12 @@ impl Buffer {
         self.indent += 1;
     }
 
-    fn dedent(&mut self) {
+    fn dedent(&mut self) -> Result<(), CompileError> {
         if self.indent == 0 {
-            panic!("dedent() called while indentation == 0");
+            return Err("dedent() called while indentation == 0".into());
         }
         self.indent -= 1;
+        Ok(())
     }
 }
 
diff --git a/askama_shared/src/heritage.rs b/askama_shared/src/heritage.rs
index a747fcf..bc9e701 100644
--- a/askama_shared/src/heritage.rs
+++ b/askama_shared/src/heritage.rs
@@ -2,7 +2,7 @@ use std::collections::HashMap;
 use std::path::{Path, PathBuf};
 
 use crate::parser::{Expr, Macro, Node};
-use crate::Config;
+use crate::{CompileError, Config};
 
 pub struct Heritage<'a> {
     pub root: &'a Context<'a>,
@@ -42,7 +42,11 @@ pub struct Context<'a> {
 }
 
 impl<'a> Context<'a> {
-    pub fn new<'n>(config: &Config, path: &Path, nodes: &'n [Node<'n>]) -> Context<'n> {
+    pub fn new<'n>(
+        config: &Config,
+        path: &Path,
+        nodes: &'n [Node<'n>],
+    ) -> Result<Context<'n>, CompileError> {
         let mut extends = None;
         let mut blocks = Vec::new();
         let mut macros = HashMap::new();
@@ -54,20 +58,22 @@ impl<'a> Context<'a> {
             for n in nodes {
                 match n {
                     Node::Extends(Expr::StrLit(extends_path)) if top => match extends {
-                        Some(_) => panic!("multiple extend blocks found"),
+                        Some(_) => return Err("multiple extend blocks found".into()),
                         None => {
-                            extends = Some(config.find_template(extends_path, Some(path)));
+                            extends = Some(config.find_template(extends_path, Some(path))?);
                         }
                     },
                     Node::Macro(name, m) if top => {
                         macros.insert(*name, m);
                     }
                     Node::Import(_, import_path, scope) if top => {
-                        let path = config.find_template(import_path, Some(path));
+                        let path = config.find_template(import_path, Some(path))?;
                         imports.insert(*scope, path);
                     }
                     Node::Extends(_) | Node::Macro(_, _) | Node::Import(_, _, _) if !top => {
-                        panic!("extends, macro or import blocks not allowed below top level");
+                        return Err(
+                            "extends, macro or import blocks not allowed below top level".into(),
+                        );
                     }
                     def @ Node::BlockDef(_, _, _, _) => {
                         blocks.push(def);
@@ -105,12 +111,12 @@ impl<'a> Context<'a> {
             })
             .collect();
 
-        Context {
+        Ok(Context {
             nodes,
             extends,
             blocks,
             macros,
             imports,
-        }
+        })
     }
 }
diff --git a/askama_shared/src/input.rs b/askama_shared/src/input.rs
index f9d10a4..ca4015a 100644
--- a/askama_shared/src/input.rs
+++ b/askama_shared/src/input.rs
@@ -1,6 +1,7 @@
-use crate::{Config, Syntax};
+use crate::{CompileError, Config, Syntax};
 
 use std::path::PathBuf;
+use std::str::FromStr;
 
 use quote::ToTokens;
 
@@ -21,7 +22,10 @@ impl<'a> TemplateInput<'a> {
     /// mostly recovers the data for the `TemplateInput` fields from the
     /// `template()` attribute list fields; it also finds the of the `_parent`
     /// field, if any.
-    pub fn new<'n>(ast: &'n syn::DeriveInput, config: &'n Config) -> TemplateInput<'n> {
+    pub fn new<'n>(
+        ast: &'n syn::DeriveInput,
+        config: &'n Config,
+    ) -> Result<TemplateInput<'n>, CompileError> {
         // Check that an attribute called `template()` exists and that it is
         // the proper type (list).
         let meta = ast
@@ -30,18 +34,18 @@ impl<'a> TemplateInput<'a> {
             .find_map(|attr| match attr.parse_meta() {
                 Ok(m) => {
                     if m.path().is_ident("template") {
-                        Some(m)
+                        Some(Ok(m))
                     } else {
                         None
                     }
                 }
-                Err(e) => panic!("unable to parse attribute: {}", e),
+                Err(e) => Some(Err(format!("unable to parse attribute: {}", e).into())),
             })
-            .expect("no attribute 'template' found");
+            .unwrap_or(Err(CompileError::Static("no attribute 'template' found")))?;
 
         let meta_list = match meta {
             syn::Meta::List(inner) => inner,
-            _ => panic!("attribute 'template' has incorrect type"),
+            _ => return Err("attribute 'template' has incorrect type".into()),
         };
 
         // Loop over the meta attributes and find everything that we
@@ -55,59 +59,63 @@ impl<'a> TemplateInput<'a> {
         for item in meta_list.nested {
             let pair = match item {
                 syn::NestedMeta::Meta(syn::Meta::NameValue(ref pair)) => pair,
-                _ => panic!(
-                    "unsupported attribute argument {:?}",
-                    item.to_token_stream()
-                ),
+                _ => {
+                    return Err(format!(
+                        "unsupported attribute argument {:?}",
+                        item.to_token_stream()
+                    )
+                    .into())
+                }
             };
 
             if pair.path.is_ident("path") {
                 if let syn::Lit::Str(ref s) = pair.lit {
                     if source.is_some() {
-                        panic!("must specify 'source' or 'path', not both");
+                        return Err("must specify 'source' or 'path', not both".into());
                     }
                     source = Some(Source::Path(s.value()));
                 } else {
-                    panic!("template path must be string literal");
+                    return Err("template path must be string literal".into());
                 }
             } else if pair.path.is_ident("source") {
                 if let syn::Lit::Str(ref s) = pair.lit {
                     if source.is_some() {
-                        panic!("must specify 'source' or 'path', not both");
+                        return Err("must specify 'source' or 'path', not both".into());
                     }
                     source = Some(Source::Source(s.value()));
                 } else {
-                    panic!("template source must be string literal");
+                    return Err("template source must be string literal".into());
                 }
             } else if pair.path.is_ident("print") {
                 if let syn::Lit::Str(ref s) = pair.lit {
-                    print = s.value().into();
+                    print = s.value().parse()?;
                 } else {
-                    panic!("print value must be string literal");
+                    return Err("print value must be string literal".into());
                 }
             } else if pair.path.is_ident("escape") {
                 if let syn::Lit::Str(ref s) = pair.lit {
                     escaping = Some(s.value());
                 } else {
-                    panic!("escape value must be string literal");
+                    return Err("escape value must be string literal".into());
                 }
             } else if pair.path.is_ident("ext") {
                 if let syn::Lit::Str(ref s) = pair.lit {
                     ext = Some(s.value());
                 } else {
-                    panic!("ext value must be string literal");
+                    return Err("ext value must be string literal".into());
                 }
             } else if pair.path.is_ident("syntax") {
                 if let syn::Lit::Str(ref s) = pair.lit {
                     syntax = Some(s.value())
                 } else {
-                    panic!("syntax value must be string literal");
+                    return Err("syntax value must be string literal".into());
                 }
             } else {
-                panic!(
+                return Err(format!(
                     "unsupported attribute key '{}' found",
                     pair.path.to_token_stream()
                 )
+                .into());
             }
         }
 
@@ -116,13 +124,13 @@ impl<'a> TemplateInput<'a> {
         // of `ext` is merged into a synthetic `path` value here.
         let source = source.expect("template path or source not found in attributes");
         let path = match (&source, &ext) {
-            (&Source::Path(ref path), None) => config.find_template(path, None),
+            (&Source::Path(ref path), None) => config.find_template(path, None)?,
             (&Source::Source(_), Some(ext)) => PathBuf::from(format!("{}.{}", ast.ident, ext)),
             (&Source::Path(_), Some(_)) => {
-                panic!("'ext' attribute cannot be used with 'path' attribute")
+                return Err("'ext' attribute cannot be used with 'path' attribute".into())
             }
             (&Source::Source(_), None) => {
-                panic!("must include 'ext' attribute when using 'source' attribute")
+                return Err("must include 'ext' attribute when using 'source' attribute".into())
             }
         };
 
@@ -149,14 +157,13 @@ impl<'a> TemplateInput<'a> {
 
         // Validate syntax
         let syntax = syntax.map_or_else(
-            || config.syntaxes.get(config.default_syntax).unwrap(),
+            || Ok(config.syntaxes.get(config.default_syntax).unwrap()),
             |s| {
-                config
-                    .syntaxes
-                    .get(&s)
-                    .unwrap_or_else(|| panic!("attribute syntax {} not exist", s))
+                config.syntaxes.get(&s).ok_or_else(|| {
+                    CompileError::String(format!("attribute syntax {} not exist", s))
+                })
             },
-        );
+        )?;
 
         // Match extension against defined output formats
 
@@ -175,11 +182,11 @@ impl<'a> TemplateInput<'a> {
             }
         }
 
-        let escaper = escaper.unwrap_or_else(|| {
-            panic!("no escaper defined for extension '{}'", extension);
-        });
+        let escaper = escaper.ok_or_else(|| {
+            CompileError::String(format!("no escaper defined for extension '{}'", extension,))
+        })?;
 
-        TemplateInput {
+        Ok(TemplateInput {
             ast,
             config,
             source,
@@ -189,7 +196,7 @@ impl<'a> TemplateInput<'a> {
             parent,
             path,
             syntax,
-        }
+        })
     }
 }
 
@@ -206,15 +213,17 @@ pub enum Print {
     None,
 }
 
-impl From<String> for Print {
-    fn from(s: String) -> Print {
+impl FromStr for Print {
+    type Err = CompileError;
+
+    fn from_str(s: &str) -> Result<Print, Self::Err> {
         use self::Print::*;
-        match s.as_ref() {
+        Ok(match s {
             "all" => All,
             "ast" => Ast,
             "code" => Code,
             "none" => None,
-            v => panic!("invalid value for print option: {}", v),
-        }
+            v => return Err(format!("invalid value for print option: {}", v,).into()),
+        })
     }
 }
diff --git a/askama_shared/src/lib.rs b/askama_shared/src/lib.rs
index 9aa93c3..e5ba402 100644
--- a/askama_shared/src/lib.rs
+++ b/askama_shared/src/lib.rs
@@ -1,9 +1,9 @@
 #![cfg_attr(feature = "cargo-clippy", allow(unused_parens))]
 
 use std::collections::{BTreeMap, HashSet};
-use std::env;
-use std::fs;
+use std::convert::TryFrom;
 use std::path::{Path, PathBuf};
+use std::{env, fmt, fs};
 
 #[cfg(feature = "serde")]
 use serde::Deserialize;
@@ -32,7 +32,7 @@ pub struct Config<'a> {
 }
 
 impl<'a> Config<'a> {
-    pub fn new(s: &str) -> Config<'_> {
+    pub fn new(s: &str) -> std::result::Result<Config<'_>, CompileError> {
         let root = PathBuf::from(env::var("CARGO_MANIFEST_DIR").unwrap());
         let default_dirs = vec![root.join("templates")];
 
@@ -42,7 +42,7 @@ impl<'a> Config<'a> {
         let raw = if s.is_empty() {
             RawConfig::default()
         } else {
-            RawConfig::from_toml_str(s)
+            RawConfig::from_toml_str(s)?
         };
 
         let (dirs, default_syntax) = match raw.general {
@@ -63,16 +63,16 @@ impl<'a> Config<'a> {
                 let name = raw_s.name;
 
                 if syntaxes
-                    .insert(name.to_string(), Syntax::from(raw_s))
+                    .insert(name.to_string(), Syntax::try_from(raw_s)?)
                     .is_some()
                 {
-                    panic!("syntax \"{}\" is already defined", name)
+                    return Err(format!("syntax \"{}\" is already defined", name).into());
                 }
             }
         }
 
         if !syntaxes.contains_key(default_syntax) {
-            panic!("default syntax \"{}\" not found", default_syntax)
+            return Err(format!("default syntax \"{}\" not found", default_syntax).into());
         }
 
         let mut escapers = Vec::new();
@@ -92,33 +92,38 @@ impl<'a> Config<'a> {
             escapers.push((str_set(extensions), (*path).to_string()));
         }
 
-        Config {
+        Ok(Config {
             dirs,
             syntaxes,
             default_syntax,
             escapers,
-        }
+        })
     }
 
-    pub fn find_template(&self, path: &str, start_at: Option<&Path>) -> PathBuf {
+    pub fn find_template(
+        &self,
+        path: &str,
+        start_at: Option<&Path>,
+    ) -> std::result::Result<PathBuf, CompileError> {
         if let Some(root) = start_at {
             let relative = root.with_file_name(path);
             if relative.exists() {
-                return relative;
+                return Ok(relative);
             }
         }
 
         for dir in &self.dirs {
             let rooted = dir.join(path);
             if rooted.exists() {
-                return rooted;
+                return Ok(rooted);
             }
         }
 
-        panic!(
+        Err(format!(
             "template {:?} not found in directories {:?}",
             path, self.dirs
         )
+        .into())
     }
 }
 
@@ -145,8 +150,10 @@ impl<'a> Default for Syntax<'a> {
     }
 }
 
-impl<'a> From<RawSyntax<'a>> for Syntax<'a> {
-    fn from(raw: RawSyntax<'a>) -> Self {
+impl<'a> TryFrom<RawSyntax<'a>> for Syntax<'a> {
+    type Error = CompileError;
+
+    fn try_from(raw: RawSyntax<'a>) -> std::result::Result<Self, Self::Error> {
         let default = Self::default();
         let syntax = Self {
             block_start: raw.block_start.unwrap_or(default.block_start),
@@ -164,7 +171,7 @@ impl<'a> From<RawSyntax<'a>> for Syntax<'a> {
             || syntax.comment_start.len() != 2
             || syntax.comment_end.len() != 2
         {
-            panic!("length of delimiters must be two")
+            return Err("length of delimiters must be two".into());
         }
 
         let bs = syntax.block_start.as_bytes()[0];
@@ -174,10 +181,10 @@ impl<'a> From<RawSyntax<'a>> for Syntax<'a> {
         let es = syntax.block_start.as_bytes()[0];
         let ee = syntax.block_start.as_bytes()[1];
         if !((bs == cs && bs == es) || (be == ce && be == ee)) {
-            panic!("bad delimiters block_start: {}, comment_start: {}, expr_start: {}, needs one of the two characters in common", syntax.block_start, syntax.comment_start, syntax.expr_start);
+            return Err(format!("bad delimiters block_start: {}, comment_start: {}, expr_start: {}, needs one of the two characters in common", syntax.block_start, syntax.comment_start, syntax.expr_start).into());
         }
 
-        syntax
+        Ok(syntax)
     }
 }
 
@@ -192,13 +199,15 @@ struct RawConfig<'d> {
 
 impl<'d> RawConfig<'d> {
     #[cfg(feature = "config")]
-    fn from_toml_str(s: &str) -> RawConfig<'_> {
-        toml::from_str(&s).unwrap_or_else(|_| panic!("invalid TOML in {}", CONFIG_FILE_NAME))
+    fn from_toml_str(s: &str) -> std::result::Result<RawConfig<'_>, CompileError> {
+        toml::from_str(&s).map_err(|e| {
+            CompileError::String(format!("invalid TOML in {}: {}", CONFIG_FILE_NAME, e))
+        })
     }
 
     #[cfg(not(feature = "config"))]
-    fn from_toml_str<'n>(_: &'n str) -> RawConfig<'n> {
-        panic!("toml support not available")
+    fn from_toml_str<'n>(_: &'n str) -> std::result::Result<RawConfig<'_>, CompileError> {
+        Err("TOML support not available".into())
     }
 }
 
@@ -226,14 +235,15 @@ struct RawEscaper<'a> {
     extensions: Vec<&'a str>,
 }
 
-pub fn read_config_file() -> String {
+pub fn read_config_file() -> std::result::Result<String, CompileError> {
     let root = PathBuf::from(env::var("CARGO_MANIFEST_DIR").unwrap());
     let filename = root.join(CONFIG_FILE_NAME);
     if filename.exists() {
-        fs::read_to_string(&filename)
-            .unwrap_or_else(|_| panic!("unable to read {}", filename.to_str().unwrap()))
+        fs::read_to_string(&filename).map_err(|_| {
+            CompileError::String(format!("unable to read {}", filename.to_str().unwrap()))
+        })
     } else {
-        "".to_string()
+        Ok("".to_string())
     }
 }
 
@@ -245,17 +255,17 @@ where
 }
 
 #[allow(clippy::match_wild_err_arm)]
-pub fn get_template_source(tpl_path: &Path) -> String {
+pub fn get_template_source(tpl_path: &Path) -> std::result::Result<String, CompileError> {
     match fs::read_to_string(tpl_path) {
-        Err(_) => panic!(
+        Err(_) => Err(CompileError::String(format!(
             "unable to open template file '{}'",
             tpl_path.to_str().unwrap()
-        ),
+        ))),
         Ok(mut source) => {
             if source.ends_with('\n') {
                 let _ = source.pop();
             }
-            source
+            Ok(source)
         }
     }
 }
@@ -279,6 +289,33 @@ static DEFAULT_ESCAPERS: &[(&[&str], &str)] = &[
     (&["j2", "jinja", "jinja2"], "::askama::Html"),
 ];
 
+#[derive(Debug)]
+pub enum CompileError {
+    Static(&'static str),
+    String(String),
+}
+
+impl fmt::Display for CompileError {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            CompileError::Static(s) => write!(fmt, "{}", s),
+            CompileError::String(s) => write!(fmt, "{}", s),
+        }
+    }
+}
+
+impl From<&'static str> for CompileError {
+    fn from(s: &'static str) -> Self {
+        CompileError::Static(s)
+    }
+}
+
+impl From<String> for CompileError {
+    fn from(s: String) -> Self {
+        CompileError::String(s)
+    }
+}
+
 #[cfg(test)]
 #[allow(clippy::blacklisted_name)]
 mod tests {
@@ -288,15 +325,17 @@ mod tests {
 
     #[test]
     fn get_source() {
-        let path = Config::new("").find_template("b.html", None);
-        assert_eq!(get_template_source(&path), "bar");
+        let path = Config::new("")
+            .and_then(|config| config.find_template("b.html", None))
+            .unwrap();
+        assert_eq!(get_template_source(&path).unwrap(), "bar");
     }
 
     #[test]
     fn test_default_config() {
         let mut root = PathBuf::from(env::var("CARGO_MANIFEST_DIR").unwrap());
         root.push("templates");
-        let config = Config::new("");
+        let config = Config::new("").unwrap();
         assert_eq!(config.dirs, vec![root]);
     }
 
@@ -305,7 +344,7 @@ mod tests {
     fn test_config_dirs() {
         let mut root = PathBuf::from(env::var("CARGO_MANIFEST_DIR").unwrap());
         root.push("tpl");
-        let config = Config::new("[general]\ndirs = [\"tpl\"]");
+        let config = Config::new("[general]\ndirs = [\"tpl\"]").unwrap();
         assert_eq!(config.dirs, vec![root]);
     }
 
@@ -319,33 +358,33 @@ mod tests {
 
     #[test]
     fn find_absolute() {
-        let config = Config::new("");
-        let root = config.find_template("a.html", None);
-        let path = config.find_template("sub/b.html", Some(&root));
+        let config = Config::new("").unwrap();
+        let root = config.find_template("a.html", None).unwrap();
+        let path = config.find_template("sub/b.html", Some(&root)).unwrap();
         assert_eq_rooted(&path, "sub/b.html");
     }
 
     #[test]
     #[should_panic]
     fn find_relative_nonexistent() {
-        let config = Config::new("");
-        let root = config.find_template("a.html", None);
-        config.find_template("c.html", Some(&root));
+        let config = Config::new("").unwrap();
+        let root = config.find_template("a.html", None).unwrap();
+        config.find_template("c.html", Some(&root)).unwrap();
     }
 
     #[test]
     fn find_relative() {
-        let config = Config::new("");
-        let root = config.find_template("sub/b.html", None);
-        let path = config.find_template("c.html", Some(&root));
+        let config = Config::new("").unwrap();
+        let root = config.find_template("sub/b.html", None).unwrap();
+        let path = config.find_template("c.html", Some(&root)).unwrap();
         assert_eq_rooted(&path, "sub/c.html");
     }
 
     #[test]
     fn find_relative_sub() {
-        let config = Config::new("");
-        let root = config.find_template("sub/b.html", None);
-        let path = config.find_template("sub1/d.html", Some(&root));
+        let config = Config::new("").unwrap();
+        let root = config.find_template("sub/b.html", None).unwrap();
+        let path = config.find_template("sub1/d.html", Some(&root)).unwrap();
         assert_eq_rooted(&path, "sub/sub1/d.html");
     }
 
@@ -366,7 +405,7 @@ mod tests {
         "#;
 
         let default_syntax = Syntax::default();
-        let config = Config::new(raw_config);
+        let config = Config::new(raw_config).unwrap();
         assert_eq!(config.default_syntax, "foo");
 
         let foo = config.syntaxes.get("foo").unwrap();
@@ -398,7 +437,7 @@ mod tests {
         "#;
 
         let default_syntax = Syntax::default();
-        let config = Config::new(raw_config);
+        let config = Config::new(raw_config).unwrap();
         assert_eq!(config.default_syntax, "foo");
 
         let foo = config.syntaxes.get("foo").unwrap();
@@ -426,7 +465,7 @@ mod tests {
         syntax = [{ name = "default" }]
         "#;
 
-        let _config = Config::new(raw_config);
+        let _config = Config::new(raw_config).unwrap();
     }
 
     #[cfg(feature = "toml")]
@@ -438,7 +477,7 @@ mod tests {
                   { name = "foo", block_start = "%%" } ]
         "#;
 
-        let _config = Config::new(raw_config);
+        let _config = Config::new(raw_config).unwrap();
     }
 
     #[cfg(feature = "toml")]
@@ -450,7 +489,7 @@ mod tests {
         default_syntax = "foo"
         "#;
 
-        let _config = Config::new(raw_config);
+        let _config = Config::new(raw_config).unwrap();
     }
 
     #[cfg(feature = "config")]
@@ -462,7 +501,8 @@ mod tests {
             path = "::askama::Js"
             extensions = ["js"]
         "#,
-        );
+        )
+        .unwrap();
         assert_eq!(
             config.escapers,
             vec![
diff --git a/askama_shared/src/parser.rs b/askama_shared/src/parser.rs
index 908ae55..9344c07 100644
--- a/askama_shared/src/parser.rs
+++ b/askama_shared/src/parser.rs
@@ -8,7 +8,7 @@ use nom::sequence::{delimited, pair, tuple};
 use nom::{self, error_position, Compare, IResult, InputTake};
 use std::str;
 
-use crate::Syntax;
+use crate::{CompileError, Syntax};
 
 #[derive(Debug, PartialEq)]
 pub enum Node<'a> {
@@ -186,7 +186,7 @@ fn take_content<'a>(i: &'a [u8], s: &'a Syntax<'a>) -> ParserError<'a, Node<'a>>
                     Any
                 }
             }
-            End(_) => panic!("cannot happen"),
+            End(_) => unreachable!(),
         };
         if let End(_) = state {
             break;
@@ -1056,19 +1056,23 @@ fn tag_expr_end<'a>(i: &'a [u8], s: &'a Syntax<'a>) -> IResult<&'a [u8], &'a [u8
     tag(s.expr_end)(i)
 }
 
-pub fn parse<'a>(src: &'a str, syntax: &'a Syntax<'a>) -> Vec<Node<'a>> {
+pub fn parse<'a>(src: &'a str, syntax: &'a Syntax<'a>) -> Result<Vec<Node<'a>>, CompileError> {
     match parse_template(src.as_bytes(), syntax) {
         Ok((left, res)) => {
             if !left.is_empty() {
                 let s = str::from_utf8(left).unwrap();
-                panic!("unable to parse template:\n\n{:?}", s);
+                Err(format!("unable to parse template:\n\n{:?}", s).into())
             } else {
-                res
+                Ok(res)
             }
         }
-        Err(nom::Err::Error(err)) => panic!("problems parsing template source: {:?}", err),
-        Err(nom::Err::Failure(err)) => panic!("problems parsing template source: {:?}", err),
-        Err(nom::Err::Incomplete(_)) => panic!("parsing incomplete"),
+        Err(nom::Err::Error(err)) => {
+            Err(format!("problems parsing template source: {:?}", err).into())
+        }
+        Err(nom::Err::Failure(err)) => {
+            Err(format!("problems parsing template source: {:?}", err).into())
+        }
+        Err(nom::Err::Incomplete(_)) => Err("parsing incomplete".into()),
     }
 }
 
@@ -1102,18 +1106,18 @@ mod tests {
     #[test]
     #[should_panic]
     fn test_invalid_block() {
-        super::parse("{% extend \"blah\" %}", &Syntax::default());
+        super::parse("{% extend \"blah\" %}", &Syntax::default()).unwrap();
     }
 
     #[test]
     fn test_parse_filter() {
-        super::parse("{{ strvar|e }}", &Syntax::default());
+        super::parse("{{ strvar|e }}", &Syntax::default()).unwrap();
     }
 
     #[test]
     fn test_parse_var_call() {
         assert_eq!(
-            super::parse("{{ function(\"123\", 3) }}", &Syntax::default()),
+            super::parse("{{ function(\"123\", 3) }}", &Syntax::default()).unwrap(),
             vec![super::Node::Expr(
                 super::WS(false, false),
                 super::Expr::VarCall(
@@ -1127,7 +1131,7 @@ mod tests {
     #[test]
     fn test_parse_path_call() {
         assert_eq!(
-            super::parse("{{ self::function(\"123\", 3) }}", &Syntax::default()),
+            super::parse("{{ self::function(\"123\", 3) }}", &Syntax::default()).unwrap(),
             vec![super::Node::Expr(
                 super::WS(false, false),
                 super::Expr::PathCall(
@@ -1146,7 +1150,7 @@ mod tests {
             ..Syntax::default()
         };
 
-        super::parse("{~ strvar|e ~}", &syntax);
+        super::parse("{~ strvar|e ~}", &syntax).unwrap();
     }
 }