Stop eliding lifetimes in paths

5 files changed, 122 insertions, 102 deletions

diff --git a/askama_shared/src/generator.rs b/askama_shared/src/generator.rs
index fc94977..8457400 100644
--- a/askama_shared/src/generator.rs
+++ b/askama_shared/src/generator.rs
@@ -16,9 +16,9 @@ use std::path::PathBuf;
 use std::{cmp, hash, mem, str};
 
 pub fn generate<S: std::hash::BuildHasher>(
-    input: &TemplateInput,
-    contexts: &HashMap<&PathBuf, Context, S>,
-    heritage: &Option<Heritage>,
+    input: &TemplateInput<'_>,
+    contexts: &HashMap<&PathBuf, Context<'_>, S>,
+    heritage: &Option<Heritage<'_>>,
     integrations: Integrations,
 ) -> Result<String, CompileError> {
     Generator::new(input, contexts, heritage, integrations, MapChain::new())
@@ -53,9 +53,9 @@ struct Generator<'a, S: std::hash::BuildHasher> {
 
 impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
     fn new<'n>(
-        input: &'n TemplateInput,
+        input: &'n TemplateInput<'_>,
         contexts: &'n HashMap<&'n PathBuf, Context<'n>, S>,
-        heritage: &'n Option<Heritage>,
+        heritage: &'n Option<Heritage<'_>>,
         integrations: Integrations,
         locals: MapChain<'n, &'n str, LocalMeta>,
     ) -> Generator<'n, S> {
@@ -85,7 +85,7 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
     }
 
     // Takes a Context and generates the relevant implementations.
-    fn build(mut self, ctx: &'a Context) -> Result<String, CompileError> {
+    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 {
@@ -121,7 +121,11 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
     }
 
     // Implement `Template` for the given context struct.
-    fn impl_template(&mut self, ctx: &'a Context, buf: &mut Buffer) -> Result<(), CompileError> {
+    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) -> \
@@ -392,8 +396,8 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
 
     fn handle(
         &mut self,
-        ctx: &'a Context,
-        nodes: &'a [Node],
+        ctx: &'a Context<'_>,
+        nodes: &'a [Node<'_>],
         buf: &mut Buffer,
         level: AstLevel,
     ) -> Result<usize, CompileError> {
@@ -469,9 +473,9 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
 
     fn write_cond(
         &mut self,
-        ctx: &'a Context,
+        ctx: &'a Context<'_>,
         buf: &mut Buffer,
-        conds: &'a [Cond],
+        conds: &'a [Cond<'_>],
         ws: Ws,
     ) -> Result<usize, CompileError> {
         let mut flushed = 0;
@@ -542,11 +546,11 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
     #[allow(clippy::too_many_arguments)]
     fn write_match(
         &mut self,
-        ctx: &'a Context,
+        ctx: &'a Context<'_>,
         buf: &mut Buffer,
         ws1: Ws,
-        expr: &Expr,
-        arms: &'a [When],
+        expr: &Expr<'_>,
+        arms: &'a [When<'_>],
         ws2: Ws,
     ) -> Result<usize, CompileError> {
         self.flush_ws(ws1);
@@ -595,12 +599,12 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
     #[allow(clippy::too_many_arguments)]
     fn write_loop(
         &mut self,
-        ctx: &'a Context,
+        ctx: &'a Context<'_>,
         buf: &mut Buffer,
         ws1: Ws,
-        var: &'a Target,
-        iter: &Expr,
-        body: &'a [Node],
+        var: &'a Target<'_>,
+        iter: &Expr<'_>,
+        body: &'a [Node<'_>],
         ws2: Ws,
     ) -> Result<usize, CompileError> {
         self.handle_ws(ws1);
@@ -657,12 +661,12 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
 
     fn write_call(
         &mut self,
-        ctx: &'a Context,
+        ctx: &'a Context<'_>,
         buf: &mut Buffer,
         ws: Ws,
         scope: Option<&str>,
         name: &str,
-        args: &[Expr],
+        args: &[Expr<'_>],
     ) -> Result<usize, CompileError> {
         if name == "super" {
             return self.write_block(buf, None, ws);
@@ -757,7 +761,7 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
 
     fn handle_include(
         &mut self,
-        ctx: &'a Context,
+        ctx: &'a Context<'_>,
         buf: &mut Buffer,
         ws: Ws,
         path: &str,
@@ -798,7 +802,7 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
         &mut self,
         buf: &mut Buffer,
         ws: Ws,
-        var: &'a Target,
+        var: &'a Target<'_>,
     ) -> Result<(), CompileError> {
         self.handle_ws(ws);
         self.write_buf_writable(buf)?;
@@ -827,8 +831,8 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
         &mut self,
         buf: &mut Buffer,
         ws: Ws,
-        var: &'a Target,
-        val: &Expr,
+        var: &'a Target<'_>,
+        val: &Expr<'_>,
     ) -> Result<(), CompileError> {
         self.handle_ws(ws);
         let mut expr_buf = Buffer::new(0);
@@ -1053,13 +1057,17 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
 
     /* Visitor methods for expression types */
 
-    fn visit_expr_root(&mut self, expr: &Expr) -> Result<String, CompileError> {
+    fn visit_expr_root(&mut self, expr: &Expr<'_>) -> Result<String, CompileError> {
         let mut buf = Buffer::new(0);
         self.visit_expr(&mut buf, expr)?;
         Ok(buf.buf)
     }
 
-    fn visit_expr(&mut self, buf: &mut Buffer, expr: &Expr) -> Result<DisplayWrap, CompileError> {
+    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),
@@ -1093,7 +1101,7 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
         DisplayWrap::Unwrapped
     }
 
-    fn visit_match_variant(&mut self, buf: &mut Buffer, param: &MatchVariant) -> DisplayWrap {
+    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) => {
@@ -1115,7 +1123,7 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
         wrapped
     }
 
-    fn visit_match_param(&mut self, buf: &mut Buffer, param: &MatchParameter) -> DisplayWrap {
+    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),
@@ -1175,7 +1183,7 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
         &mut self,
         buf: &mut Buffer,
         mut name: &str,
-        args: &[Expr],
+        args: &[Expr<'_>],
     ) -> Result<DisplayWrap, CompileError> {
         if name == "format" {
             self._visit_format_filter(buf, args)?;
@@ -1224,7 +1232,7 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
     fn _visit_format_filter(
         &mut self,
         buf: &mut Buffer,
-        args: &[Expr],
+        args: &[Expr<'_>],
     ) -> Result<(), CompileError> {
         buf.write("format!(");
         if let Some(Expr::StrLit(v)) = args.first() {
@@ -1240,7 +1248,11 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
         Ok(())
     }
 
-    fn _visit_fmt_filter(&mut self, buf: &mut Buffer, args: &[Expr]) -> Result<(), CompileError> {
+    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);
@@ -1257,7 +1269,11 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
     }
 
     // Force type coercion on first argument to `join` filter (see #39).
-    fn _visit_join_filter(&mut self, buf: &mut Buffer, args: &[Expr]) -> Result<(), CompileError> {
+    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 {
@@ -1272,7 +1288,7 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
         Ok(())
     }
 
-    fn _visit_args(&mut self, buf: &mut Buffer, args: &[Expr]) -> Result<(), CompileError> {
+    fn _visit_args(&mut self, buf: &mut Buffer, args: &[Expr<'_>]) -> Result<(), CompileError> {
         if args.is_empty() {
             return Ok(());
         }
@@ -1313,7 +1329,7 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
     fn visit_attr(
         &mut self,
         buf: &mut Buffer,
-        obj: &Expr,
+        obj: &Expr<'_>,
         attr: &str,
     ) -> Result<DisplayWrap, CompileError> {
         if let Expr::Var(name) = *obj {
@@ -1343,8 +1359,8 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
     fn visit_index(
         &mut self,
         buf: &mut Buffer,
-        obj: &Expr,
-        key: &Expr,
+        obj: &Expr<'_>,
+        key: &Expr<'_>,
     ) -> Result<DisplayWrap, CompileError> {
         buf.write("&");
         self.visit_expr(buf, obj)?;
@@ -1357,9 +1373,9 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
     fn visit_method_call(
         &mut self,
         buf: &mut Buffer,
-        obj: &Expr,
+        obj: &Expr<'_>,
         method: &str,
-        args: &[Expr],
+        args: &[Expr<'_>],
     ) -> Result<DisplayWrap, CompileError> {
         if let Expr::Var("self") = obj {
             buf.write("self");
@@ -1377,7 +1393,7 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
         &mut self,
         buf: &mut Buffer,
         op: &str,
-        inner: &Expr,
+        inner: &Expr<'_>,
     ) -> Result<DisplayWrap, CompileError> {
         buf.write(op);
         self.visit_expr(buf, inner)?;
@@ -1388,8 +1404,8 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
         &mut self,
         buf: &mut Buffer,
         op: &str,
-        left: &Option<Box<Expr>>,
-        right: &Option<Box<Expr>>,
+        left: &Option<Box<Expr<'_>>>,
+        right: &Option<Box<Expr<'_>>>,
     ) -> Result<DisplayWrap, CompileError> {
         if let Some(left) = left {
             self.visit_expr(buf, left)?;
@@ -1405,8 +1421,8 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
         &mut self,
         buf: &mut Buffer,
         op: &str,
-        left: &Expr,
-        right: &Expr,
+        left: &Expr<'_>,
+        right: &Expr<'_>,
     ) -> Result<DisplayWrap, CompileError> {
         self.visit_expr(buf, left)?;
         buf.write(&format!(" {} ", op));
@@ -1414,7 +1430,11 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
         Ok(DisplayWrap::Unwrapped)
     }
 
-    fn visit_group(&mut self, buf: &mut Buffer, inner: &Expr) -> Result<DisplayWrap, CompileError> {
+    fn visit_group(
+        &mut self,
+        buf: &mut Buffer,
+        inner: &Expr<'_>,
+    ) -> Result<DisplayWrap, CompileError> {
         buf.write("(");
         self.visit_expr(buf, inner)?;
         buf.write(")");
@@ -1424,7 +1444,7 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
     fn visit_array(
         &mut self,
         buf: &mut Buffer,
-        elements: &[Expr],
+        elements: &[Expr<'_>],
     ) -> Result<DisplayWrap, CompileError> {
         buf.write("[");
         for (i, el) in elements.iter().enumerate() {
@@ -1451,7 +1471,7 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
         &mut self,
         buf: &mut Buffer,
         path: &[&str],
-        args: &[Expr],
+        args: &[Expr<'_>],
     ) -> Result<DisplayWrap, CompileError> {
         for (i, part) in path.iter().enumerate() {
             if i > 0 {
@@ -1479,7 +1499,7 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
         &mut self,
         buf: &mut Buffer,
         s: &str,
-        args: &[Expr],
+        args: &[Expr<'_>],
     ) -> Result<DisplayWrap, CompileError> {
         buf.write("(");
         let s = normalize_identifier(s);
@@ -1513,7 +1533,7 @@ impl<'a, S: std::hash::BuildHasher> Generator<'a, S> {
         DisplayWrap::Unwrapped
     }
 
-    fn visit_target(&mut self, buf: &mut Buffer, target: &'a Target) {
+    fn visit_target(&mut self, buf: &mut Buffer, target: &'a Target<'_>) {
         match *target {
             Target::Name(name) => {
                 let name = normalize_identifier(name);
@@ -1663,7 +1683,7 @@ where
         }
     }
 
-    fn with_parent<'p>(parent: &'p MapChain<K, V>) -> MapChain<'p, K, V> {
+    fn with_parent<'p>(parent: &'p MapChain<'_, K, V>) -> MapChain<'p, K, V> {
         MapChain {
             parent: Some(parent),
             scopes: vec![HashMap::new()],
diff --git a/askama_shared/src/heritage.rs b/askama_shared/src/heritage.rs
index 87f23e0..c03163d 100644
--- a/askama_shared/src/heritage.rs
+++ b/askama_shared/src/heritage.rs
@@ -43,7 +43,7 @@ pub struct Context<'a> {
 
 impl<'a> Context<'a> {
     pub fn new<'n>(
-        config: &Config,
+        config: &Config<'_>,
         path: &Path,
         nodes: &'n [Node<'n>],
     ) -> Result<Context<'n>, CompileError> {
diff --git a/askama_shared/src/input.rs b/askama_shared/src/input.rs
index 8986fea..c94c217 100644
--- a/askama_shared/src/input.rs
+++ b/askama_shared/src/input.rs
@@ -24,7 +24,7 @@ impl<'a> TemplateInput<'a> {
     /// field, if any.
     pub fn new<'n>(
         ast: &'n syn::DeriveInput,
-        config: &'n Config,
+        config: &'n Config<'_>,
     ) -> Result<TemplateInput<'n>, CompileError> {
         // Check that an attribute called `template()` exists and that it is
         // the proper type (list).
diff --git a/askama_shared/src/lib.rs b/askama_shared/src/lib.rs
index 0b1f375..f217cfb 100644
--- a/askama_shared/src/lib.rs
+++ b/askama_shared/src/lib.rs
@@ -1,4 +1,5 @@
 #![cfg_attr(feature = "cargo-clippy", allow(unused_parens))]
+#![deny(elided_lifetimes_in_paths)]
 
 use std::collections::{BTreeMap, HashSet};
 use std::convert::TryFrom;
diff --git a/askama_shared/src/parser.rs b/askama_shared/src/parser.rs
index 3c5a86c..5610a24 100644
--- a/askama_shared/src/parser.rs
+++ b/askama_shared/src/parser.rs
@@ -172,7 +172,7 @@ where
     }
 }
 
-fn split_ws_parts(s: &[u8]) -> Node {
+fn split_ws_parts(s: &[u8]) -> Node<'_> {
     if s.is_empty() {
         let rs = str::from_utf8(s).unwrap();
         return Node::Lit(rs, rs, rs);
@@ -249,7 +249,7 @@ fn take_content<'a>(i: &'a [u8], s: &'a Syntax<'a>) -> ParserError<'a, Node<'a>>
     }
 }
 
-fn identifier(input: &[u8]) -> ParserError<&str> {
+fn identifier(input: &[u8]) -> ParserError<'_, &str> {
     if !nom::character::is_alphabetic(input[0]) && input[0] != b'_' && !non_ascii(input[0]) {
         return Err(nom::Err::Error(nom::error::Error::new(
             input,
@@ -270,7 +270,7 @@ fn non_ascii(chr: u8) -> bool {
     (0x80..=0xFD).contains(&chr)
 }
 
-fn expr_bool_lit(i: &[u8]) -> IResult<&[u8], Expr> {
+fn expr_bool_lit(i: &[u8]) -> IResult<&[u8], Expr<'_>> {
     map(alt((tag("false"), tag("true"))), |s| {
         Expr::BoolLit(str::from_utf8(s).unwrap())
     })(i)
@@ -282,11 +282,11 @@ fn num_lit(i: &[u8]) -> IResult<&[u8], &str> {
     })(i)
 }
 
-fn expr_num_lit(i: &[u8]) -> IResult<&[u8], Expr> {
+fn expr_num_lit(i: &[u8]) -> IResult<&[u8], Expr<'_>> {
     map(num_lit, |s| Expr::NumLit(s))(i)
 }
 
-fn expr_array_lit(i: &[u8]) -> IResult<&[u8], Expr> {
+fn expr_array_lit(i: &[u8]) -> IResult<&[u8], Expr<'_>> {
     delimited(
         ws(tag("[")),
         map(separated_list1(ws(tag(",")), expr_any), |arr| {
@@ -296,11 +296,11 @@ fn expr_array_lit(i: &[u8]) -> IResult<&[u8], Expr> {
     )(i)
 }
 
-fn variant_num_lit(i: &[u8]) -> IResult<&[u8], MatchVariant> {
+fn variant_num_lit(i: &[u8]) -> IResult<&[u8], MatchVariant<'_>> {
     map(num_lit, |s| MatchVariant::NumLit(s))(i)
 }
 
-fn param_num_lit(i: &[u8]) -> IResult<&[u8], MatchParameter> {
+fn param_num_lit(i: &[u8]) -> IResult<&[u8], MatchParameter<'_>> {
     map(num_lit, |s| MatchParameter::NumLit(s))(i)
 }
 
@@ -315,15 +315,15 @@ fn str_lit(i: &[u8]) -> IResult<&[u8], &str> {
     )(i)
 }
 
-fn expr_str_lit(i: &[u8]) -> IResult<&[u8], Expr> {
+fn expr_str_lit(i: &[u8]) -> IResult<&[u8], Expr<'_>> {
     map(str_lit, |s| Expr::StrLit(s))(i)
 }
 
-fn variant_str_lit(i: &[u8]) -> IResult<&[u8], MatchVariant> {
+fn variant_str_lit(i: &[u8]) -> IResult<&[u8], MatchVariant<'_>> {
     map(str_lit, |s| MatchVariant::StrLit(s))(i)
 }
 
-fn param_str_lit(i: &[u8]) -> IResult<&[u8], MatchParameter> {
+fn param_str_lit(i: &[u8]) -> IResult<&[u8], MatchParameter<'_>> {
     map(str_lit, |s| MatchParameter::StrLit(s))(i)
 }
 
@@ -338,23 +338,23 @@ fn char_lit(i: &[u8]) -> IResult<&[u8], &str> {
     )(i)
 }
 
-fn expr_char_lit(i: &[u8]) -> IResult<&[u8], Expr> {
+fn expr_char_lit(i: &[u8]) -> IResult<&[u8], Expr<'_>> {
     map(char_lit, |s| Expr::CharLit(s))(i)
 }
 
-fn variant_char_lit(i: &[u8]) -> IResult<&[u8], MatchVariant> {
+fn variant_char_lit(i: &[u8]) -> IResult<&[u8], MatchVariant<'_>> {
     map(char_lit, |s| MatchVariant::CharLit(s))(i)
 }
 
-fn param_char_lit(i: &[u8]) -> IResult<&[u8], MatchParameter> {
+fn param_char_lit(i: &[u8]) -> IResult<&[u8], MatchParameter<'_>> {
     map(char_lit, |s| MatchParameter::CharLit(s))(i)
 }
 
-fn expr_var(i: &[u8]) -> IResult<&[u8], Expr> {
+fn expr_var(i: &[u8]) -> IResult<&[u8], Expr<'_>> {
     map(identifier, |s| Expr::Var(s))(i)
 }
 
-fn expr_var_call(i: &[u8]) -> IResult<&[u8], Expr> {
+fn expr_var_call(i: &[u8]) -> IResult<&[u8], Expr<'_>> {
     let (i, (s, args)) = tuple((ws(identifier), arguments))(i)?;
     Ok((i, Expr::VarCall(s, args)))
 }
@@ -388,27 +388,27 @@ fn path(i: &[u8]) -> IResult<&[u8], Vec<&str>> {
     }
 }
 
-fn expr_path(i: &[u8]) -> IResult<&[u8], Expr> {
+fn expr_path(i: &[u8]) -> IResult<&[u8], Expr<'_>> {
     let (i, path) = path(i)?;
     Ok((i, Expr::Path(path)))
 }
 
-fn expr_path_call(i: &[u8]) -> IResult<&[u8], Expr> {
+fn expr_path_call(i: &[u8]) -> IResult<&[u8], Expr<'_>> {
     let (i, (path, args)) = tuple((ws(path), arguments))(i)?;
     Ok((i, Expr::PathCall(path, args)))
 }
 
-fn variant_path(i: &[u8]) -> IResult<&[u8], MatchVariant> {
+fn variant_path(i: &[u8]) -> IResult<&[u8], MatchVariant<'_>> {
     map(separated_list1(ws(tag("::")), identifier), |path| {
         MatchVariant::Path(path)
     })(i)
 }
 
-fn target_single(i: &[u8]) -> IResult<&[u8], Target> {
+fn target_single(i: &[u8]) -> IResult<&[u8], Target<'_>> {
     map(identifier, |s| Target::Name(s))(i)
 }
 
-fn target_tuple(i: &[u8]) -> IResult<&[u8], Target> {
+fn target_tuple(i: &[u8]) -> IResult<&[u8], Target<'_>> {
     let parts = separated_list0(tag(","), ws(identifier));
     let trailing = opt(ws(tag(",")));
     let mut full = delimited(tag("("), tuple((parts, trailing)), tag(")"));
@@ -417,15 +417,15 @@ fn target_tuple(i: &[u8]) -> IResult<&[u8], Target> {
     Ok((i, Target::Tuple(elems)))
 }
 
-fn variant_name(i: &[u8]) -> IResult<&[u8], MatchVariant> {
+fn variant_name(i: &[u8]) -> IResult<&[u8], MatchVariant<'_>> {
     map(identifier, |s| MatchVariant::Name(s))(i)
 }
 
-fn param_name(i: &[u8]) -> IResult<&[u8], MatchParameter> {
+fn param_name(i: &[u8]) -> IResult<&[u8], MatchParameter<'_>> {
     map(identifier, |s| MatchParameter::Name(s))(i)
 }
 
-fn arguments(i: &[u8]) -> IResult<&[u8], Vec<Expr>> {
+fn arguments(i: &[u8]) -> IResult<&[u8], Vec<Expr<'_>>> {
     delimited(
         ws(tag("(")),
         separated_list0(tag(","), ws(expr_any)),
@@ -437,7 +437,7 @@ fn macro_arguments(i: &[u8]) -> IResult<&[u8], &str> {
     delimited(char('('), nested_parenthesis, char(')'))(i)
 }
 
-fn nested_parenthesis(i: &[u8]) -> ParserError<&str> {
+fn nested_parenthesis(i: &[u8]) -> ParserError<'_, &str> {
     let mut nested = 0;
     let mut last = 0;
     let mut in_str = false;
@@ -493,7 +493,7 @@ fn parameters(i: &[u8]) -> IResult<&[u8], Vec<&str>> {
     )(i)
 }
 
-fn with_parameters(i: &[u8]) -> IResult<&[u8], MatchParameters> {
+fn with_parameters(i: &[u8]) -> IResult<&[u8], MatchParameters<'_>> {
     let (i, (_, value)) = tuple((
         tag("with"),
         alt((match_simple_parameters, match_named_parameters)),
@@ -501,7 +501,7 @@ fn with_parameters(i: &[u8]) -> IResult<&[u8], MatchParameters> {
     Ok((i, value))
 }
 
-fn match_simple_parameters(i: &[u8]) -> IResult<&[u8], MatchParameters> {
+fn match_simple_parameters(i: &[u8]) -> IResult<&[u8], MatchParameters<'_>> {
     delimited(
         ws(tag("(")),
         map(separated_list0(tag(","), ws(match_parameter)), |mps| {
@@ -511,7 +511,7 @@ fn match_simple_parameters(i: &[u8]) -> IResult<&[u8], MatchParameters> {
     )(i)
 }
 
-fn match_named_parameters(i: &[u8]) -> IResult<&[u8], MatchParameters> {
+fn match_named_parameters(i: &[u8]) -> IResult<&[u8], MatchParameters<'_>> {
     delimited(
         ws(tag("{")),
         map(
@@ -522,13 +522,13 @@ fn match_named_parameters(i: &[u8]) -> IResult<&[u8], MatchParameters> {
     )(i)
 }
 
-fn expr_group(i: &[u8]) -> IResult<&[u8], Expr> {
+fn expr_group(i: &[u8]) -> IResult<&[u8], Expr<'_>> {
     map(delimited(ws(char('(')), expr_any, ws(char(')'))), |s| {
         Expr::Group(Box::new(s))
     })(i)
 }
 
-fn expr_single(i: &[u8]) -> IResult<&[u8], Expr> {
+fn expr_single(i: &[u8]) -> IResult<&[u8], Expr<'_>> {
     alt((
         expr_bool_lit,
         expr_num_lit,
@@ -544,7 +544,7 @@ fn expr_single(i: &[u8]) -> IResult<&[u8], Expr> {
     ))(i)
 }
 
-fn match_variant(i: &[u8]) -> IResult<&[u8], MatchVariant> {
+fn match_variant(i: &[u8]) -> IResult<&[u8], MatchVariant<'_>> {
     alt((
         variant_path,
         variant_name,
@@ -554,23 +554,23 @@ fn match_variant(i: &[u8]) -> IResult<&[u8], MatchVariant> {
     ))(i)
 }
 
-fn match_parameter(i: &[u8]) -> IResult<&[u8], MatchParameter> {
+fn match_parameter(i: &[u8]) -> IResult<&[u8], MatchParameter<'_>> {
     alt((param_name, param_num_lit, param_str_lit, param_char_lit))(i)
 }
 
-fn match_named_parameter(i: &[u8]) -> IResult<&[u8], (&str, Option<MatchParameter>)> {
+fn match_named_parameter(i: &[u8]) -> IResult<&[u8], (&str, Option<MatchParameter<'_>>)> {
     let param = tuple((ws(tag(":")), match_parameter));
     let (i, (name, param)) = tuple((identifier, opt(param)))(i)?;
     Ok((i, (name, param.map(|s| s.1))))
 }
 
-fn attr(i: &[u8]) -> IResult<&[u8], (&str, Option<Vec<Expr>>)> {
+fn attr(i: &[u8]) -> IResult<&[u8], (&str, Option<Vec<Expr<'_>>>)> {
     let (i, (_, attr, args)) =
         tuple((ws(tag(".")), alt((num_lit, identifier)), ws(opt(arguments))))(i)?;
     Ok((i, (attr, args)))
 }
 
-fn expr_attr(i: &[u8]) -> IResult<&[u8], Expr> {
+fn expr_attr(i: &[u8]) -> IResult<&[u8], Expr<'_>> {
     let (i, (obj, attrs)) = tuple((expr_single, many0(attr)))(i)?;
 
     let mut res = obj;
@@ -585,7 +585,7 @@ fn expr_attr(i: &[u8]) -> IResult<&[u8], Expr> {
     Ok((i, res))
 }
 
-fn expr_index(i: &[u8]) -> IResult<&[u8], Expr> {
+fn expr_index(i: &[u8]) -> IResult<&[u8], Expr<'_>> {
     let key = opt(tuple((ws(tag("[")), expr_any, ws(tag("]")))));
     let (i, (obj, key)) = tuple((expr_attr, key))(i)?;
     let key = key.map(|(_, key, _)| key);
@@ -599,12 +599,12 @@ fn expr_index(i: &[u8]) -> IResult<&[u8], Expr> {
     ))
 }
 
-fn filter(i: &[u8]) -> IResult<&[u8], (&str, Option<Vec<Expr>>)> {
+fn filter(i: &[u8]) -> IResult<&[u8], (&str, Option<Vec<Expr<'_>>>)> {
     let (i, (_, fname, args)) = tuple((tag("|"), ws(identifier), opt(arguments)))(i)?;
     Ok((i, (fname, args)))
 }
 
-fn expr_filtered(i: &[u8]) -> IResult<&[u8], Expr> {
+fn expr_filtered(i: &[u8]) -> IResult<&[u8], Expr<'_>> {
     let (i, (obj, filters)) = tuple((expr_unary, many0(filter)))(i)?;
 
     let mut res = obj;
@@ -622,7 +622,7 @@ fn expr_filtered(i: &[u8]) -> IResult<&[u8], Expr> {
     Ok((i, res))
 }
 
-fn expr_unary(i: &[u8]) -> IResult<&[u8], Expr> {
+fn expr_unary(i: &[u8]) -> IResult<&[u8], Expr<'_>> {
     let (i, (op, expr)) = tuple((opt(alt((ws(tag("!")), ws(tag("-"))))), expr_index))(i)?;
     Ok((
         i,
@@ -633,14 +633,14 @@ fn expr_unary(i: &[u8]) -> IResult<&[u8], Expr> {
     ))
 }
 
-fn expr_rust_macro(i: &[u8]) -> IResult<&[u8], Expr> {
+fn expr_rust_macro(i: &[u8]) -> IResult<&[u8], Expr<'_>> {
     let (i, (mname, _, args)) = tuple((identifier, tag("!"), macro_arguments))(i)?;
     Ok((i, Expr::RustMacro(mname, args)))
 }
 
 macro_rules! expr_prec_layer {
     ( $name:ident, $inner:ident, $op:expr ) => {
-        fn $name(i: &[u8]) -> IResult<&[u8], Expr> {
+        fn $name(i: &[u8]) -> IResult<&[u8], Expr<'_>> {
             let (i, left) = $inner(i)?;
             let (i, right) = many0(pair(
                 ws(tag($op)),
@@ -655,7 +655,7 @@ macro_rules! expr_prec_layer {
         }
     };
     ( $name:ident, $inner:ident, $( $op:expr ),+ ) => {
-        fn $name(i: &[u8]) -> IResult<&[u8], Expr> {
+        fn $name(i: &[u8]) -> IResult<&[u8], Expr<'_>> {
             let (i, left) = $inner(i)?;
             let (i, right) = many0(pair(
                 ws(alt(($( tag($op) ),*,))),
@@ -681,7 +681,7 @@ expr_prec_layer!(expr_compare, expr_bor, "==", "!=", ">=", ">", "<=", "<");
 expr_prec_layer!(expr_and, expr_compare, "&&");
 expr_prec_layer!(expr_or, expr_and, "||");
 
-fn range_right(i: &[u8]) -> IResult<&[u8], Expr> {
+fn range_right(i: &[u8]) -> IResult<&[u8], Expr<'_>> {
     let (i, (_, incl, right)) = tuple((ws(tag("..")), opt(ws(tag("="))), opt(expr_or)))(i)?;
     Ok((
         i,
@@ -693,7 +693,7 @@ fn range_right(i: &[u8]) -> IResult<&[u8], Expr> {
     ))
 }
 
-fn expr_any(i: &[u8]) -> IResult<&[u8], Expr> {
+fn expr_any(i: &[u8]) -> IResult<&[u8], Expr<'_>> {
     let compound = map(tuple((expr_or, range_right)), |(left, rest)| match rest {
         Expr::Range(op, _, right) => Expr::Range(op, Some(Box::new(left)), right),
         _ => unreachable!(),
@@ -713,7 +713,7 @@ fn expr_node<'a>(i: &'a [u8], s: &'a Syntax<'a>) -> IResult<&'a [u8], Node<'a>>
     Ok((i, Node::Expr(Ws(pws.is_some(), nws.is_some()), expr)))
 }
 
-fn block_call(i: &[u8]) -> IResult<&[u8], Node> {
+fn block_call(i: &[u8]) -> IResult<&[u8], Node<'_>> {
     let mut p = tuple((
         opt(tag("-")),
         ws(tag("call")),
@@ -730,7 +730,7 @@ fn block_call(i: &[u8]) -> IResult<&[u8], Node> {
     ))
 }
 
-fn cond_if(i: &[u8]) -> IResult<&[u8], CondTest> {
+fn cond_if(i: &[u8]) -> IResult<&[u8], CondTest<'_>> {
     let mut p = tuple((
         ws(tag("if")),
         opt(tuple((
@@ -879,7 +879,7 @@ fn block_match<'a>(i: &'a [u8], s: &'a Syntax<'a>) -> IResult<&'a [u8], Node<'a>
     ))
 }
 
-fn block_let(i: &[u8]) -> IResult<&[u8], Node> {
+fn block_let(i: &[u8]) -> IResult<&[u8], Node<'_>> {
     let mut p = tuple((
         opt(tag("-")),
         ws(alt((tag("let"), tag("set")))),
@@ -927,7 +927,7 @@ fn block_for<'a>(i: &'a [u8], s: &'a Syntax<'a>) -> IResult<&'a [u8], Node<'a>>
     ))
 }
 
-fn block_extends(i: &[u8]) -> IResult<&[u8], Node> {
+fn block_extends(i: &[u8]) -> IResult<&[u8], Node<'_>> {
     let (i, (_, name)) = tuple((ws(tag("extends")), ws(expr_str_lit)))(i)?;
     Ok((i, Node::Extends(name)))
 }
@@ -963,7 +963,7 @@ fn block_block<'a>(i: &'a [u8], s: &'a Syntax<'a>) -> IResult<&'a [u8], Node<'a>
     ))
 }
 
-fn block_include(i: &[u8]) -> IResult<&[u8], Node> {
+fn block_include(i: &[u8]) -> IResult<&[u8], Node<'_>> {
     let mut p = tuple((
         opt(tag("-")),
         ws(tag("include")),
@@ -983,7 +983,7 @@ fn block_include(i: &[u8]) -> IResult<&[u8], Node> {
     ))
 }
 
-fn block_import(i: &[u8]) -> IResult<&[u8], Node> {
+fn block_import(i: &[u8]) -> IResult<&[u8], Node<'_>> {
     let mut p = tuple((
         opt(tag("-")),
         ws(tag("import")),
@@ -1170,8 +1170,7 @@ mod tests {
     use crate::Syntax;
 
     fn check_ws_split(s: &str, res: &(&str, &str, &str)) {
-        let node = super::split_ws_parts(s.as_bytes());
-        match node {
+        match super::split_ws_parts(s.as_bytes()) {
             Node::Lit(lws, s, rws) => {
                 assert_eq!(lws, res.0);
                 assert_eq!(s, res.1);