diff --git a/askama/src/filters/json.rs b/askama/src/filters/json.rs
index b040767f..5a12d43b 100644
--- a/askama/src/filters/json.rs
+++ b/askama/src/filters/json.rs
@@ -195,10 +195,10 @@ where
 fn get_escaped(byte: u8) -> Option<[AsciiChar; 2]> {
     const _: () = assert!(CHAR_RANGE < 32);
 
-    if let MIN_CHAR..=MAX_CHAR = byte {
-        if (1u32 << (byte - MIN_CHAR)) & BITS != 0 {
-            return Some(TABLE.0[(byte - MIN_CHAR) as usize]);
-        }
+    if let MIN_CHAR..=MAX_CHAR = byte
+        && (1u32 << (byte - MIN_CHAR)) & BITS != 0
+    {
+        return Some(TABLE.0[(byte - MIN_CHAR) as usize]);
     }
     None
 }
diff --git a/askama/src/helpers.rs b/askama/src/helpers.rs
index 981e6594..2855a5bd 100644
--- a/askama/src/helpers.rs
+++ b/askama/src/helpers.rs
@@ -90,11 +90,11 @@ where
 {
     #[inline]
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        if let Some(func) = self.func.take() {
-            if let Err(err) = func(f) {
-                self.err.set(Some(err));
-                return Err(fmt::Error);
-            }
+        if let Some(func) = self.func.take()
+            && let Err(err) = func(f)
+        {
+            self.err.set(Some(err));
+            return Err(fmt::Error);
         }
         Ok(())
     }
diff --git a/askama_derive/src/generator/expr.rs b/askama_derive/src/generator/expr.rs
index ac2659bd..a63bf403 100644
--- a/askama_derive/src/generator/expr.rs
+++ b/askama_derive/src/generator/expr.rs
@@ -673,14 +673,14 @@ impl<'a> Generator<'a, '_> {
         for (i, part) in path.iter().copied().enumerate() {
             if i > 0 {
                 buf.write("::");
-            } else if let Some(enum_ast) = self.input.enum_ast {
-                if part == "Self" {
-                    let this = &enum_ast.ident;
-                    let (_, generics, _) = enum_ast.generics.split_for_impl();
-                    let generics = generics.as_turbofish();
-                    buf.write(quote!(#this #generics));
-                    continue;
-                }
+            } else if let Some(enum_ast) = self.input.enum_ast
+                && part == "Self"
+            {
+                let this = &enum_ast.ident;
+                let (_, generics, _) = enum_ast.generics.split_for_impl();
+                let generics = generics.as_turbofish();
+                buf.write(quote!(#this #generics));
+                continue;
             }
             buf.write(part);
         }
diff --git a/askama_derive/src/generator/filter.rs b/askama_derive/src/generator/filter.rs
index e8476978..6bd52d2d 100644
--- a/askama_derive/src/generator/filter.rs
+++ b/askama_derive/src/generator/filter.rs
@@ -562,17 +562,17 @@ impl<'a> Generator<'a, '_> {
     ) -> Result<DisplayWrap, CompileError> {
         ensure_filter_has_feature_alloc(ctx, "format", node)?;
         ensure_no_named_arguments(ctx, "format", args, node)?;
-        if !args.is_empty() {
-            if let Expr::StrLit(ref fmt) = *args[0] {
-                buf.write("askama::helpers::alloc::format!(");
-                self.visit_str_lit(buf, fmt);
-                if args.len() > 1 {
-                    buf.write(',');
-                    self.visit_args(ctx, buf, &args[1..])?;
-                }
-                buf.write(')');
-                return Ok(DisplayWrap::Unwrapped);
+        if !args.is_empty()
+            && let Expr::StrLit(ref fmt) = *args[0]
+        {
+            buf.write("askama::helpers::alloc::format!(");
+            self.visit_str_lit(buf, fmt);
+            if args.len() > 1 {
+                buf.write(',');
+                self.visit_args(ctx, buf, &args[1..])?;
             }
+            buf.write(')');
+            return Ok(DisplayWrap::Unwrapped);
         }
         Err(ctx.generate_error(
             r#"use `format` filter like `"a={} b={}"|format(a, b)`"#,
diff --git a/askama_derive/src/generator/node.rs b/askama_derive/src/generator/node.rs
index 4cb22df6..19103927 100644
--- a/askama_derive/src/generator/node.rs
+++ b/askama_derive/src/generator/node.rs
@@ -1585,17 +1585,17 @@ fn macro_call_ensure_arg_count(
             }
             _ => Some(pos),
         };
-        if let Some(pos) = pos {
-            if mem::take(&mut args[pos]).is_none() {
-                // This argument was already passed, so error.
-                return Err(ctx.generate_error(
-                    format_args!(
-                        "argument `{}` was passed more than once when calling macro `{}`",
-                        def.args[pos].0, def.name,
-                    ),
-                    call.span(),
-                ));
-            }
+        if let Some(pos) = pos
+            && mem::take(&mut args[pos]).is_none()
+        {
+            // This argument was already passed, so error.
+            return Err(ctx.generate_error(
+                format_args!(
+                    "argument `{}` was passed more than once when calling macro `{}`",
+                    def.args[pos].0, def.name,
+                ),
+                call.span(),
+            ));
         }
     }
 
diff --git a/askama_derive/src/integration.rs b/askama_derive/src/integration.rs
index 0d65ceda..56f833dd 100644
--- a/askama_derive/src/integration.rs
+++ b/askama_derive/src/integration.rs
@@ -386,10 +386,10 @@ where
     A: FnMut(&mut S) -> &mut Option<T>,
 {
     let dest = access(dest);
-    if dest.is_none() {
-        if let Some(parent) = access(parent) {
-            *dest = Some(parent.clone());
-        }
+    if dest.is_none()
+        && let Some(parent) = access(parent)
+    {
+        *dest = Some(parent.clone());
     }
 }
 
diff --git a/askama_derive/src/lib.rs b/askama_derive/src/lib.rs
index c55bedd9..8eb5c5dc 100644
--- a/askama_derive/src/lib.rs
+++ b/askama_derive/src/lib.rs
@@ -331,10 +331,10 @@ pub(crate) fn build_template(
             build_template_enum(buf, ast, enum_args, vars_args, has_default_impl)
         }
     };
-    if let Err(err) = &mut result {
-        if err.span.is_none() {
-            err.span = err_span;
-        }
+    if let Err(err) = &mut result
+        && err.span.is_none()
+    {
+        err.span = err_span;
     }
     result
 }
diff --git a/askama_parser/src/expr.rs b/askama_parser/src/expr.rs
index 4ee411ab..5c6ebaf8 100644
--- a/askama_parser/src/expr.rs
+++ b/askama_parser/src/expr.rs
@@ -71,10 +71,10 @@ fn check_expr<'a>(expr: &WithSpan<'a, Expr<'a>>, allowed: Allowed) -> ParseResul
             }
         }
         Expr::Path(path) => {
-            if let &[name] = path.as_slice() {
-                if !crate::can_be_variable_name(name) {
-                    return err_reserved_identifier(name);
-                }
+            if let &[name] = path.as_slice()
+                && !crate::can_be_variable_name(name)
+            {
+                return err_reserved_identifier(name);
             }
             Ok(())
         }
@@ -996,25 +996,24 @@ impl<'a> Suffix<'a> {
             const THREE_CHARS: &[&str] = &["<<=", ">>=", "...", "..="];
 
             // need to check long to short
-            if let Some((head, tail)) = i.split_at_checked(3) {
-                if THREE_CHARS.contains(&head) {
-                    *i = tail;
-                    return Ok(());
-                }
+            if let Some((head, tail)) = i.split_at_checked(3)
+                && THREE_CHARS.contains(&head)
+            {
+                *i = tail;
+                return Ok(());
             }
-            if let Some((head, tail)) = i.split_at_checked(2) {
-                if TWO_CHARS.contains(&head) {
-                    *i = tail;
-                    return Ok(());
-                }
+            if let Some((head, tail)) = i.split_at_checked(2)
+                && TWO_CHARS.contains(&head)
+            {
+                *i = tail;
+                return Ok(());
             }
-            if let Some((head, tail)) = i.split_at_checked(1) {
-                if let [head] = head.as_bytes() {
-                    if ONE_CHAR.contains(head) {
-                        *i = tail;
-                        return Ok(());
-                    }
-                }
+            if let Some((head, tail)) = i.split_at_checked(1)
+                && let [head] = head.as_bytes()
+                && ONE_CHAR.contains(head)
+            {
+                *i = tail;
+                return Ok(());
             }
             fail(i)
         }
diff --git a/askama_parser/src/node.rs b/askama_parser/src/node.rs
index a92020ad..d6e1e2d7 100644
--- a/askama_parser/src/node.rs
+++ b/askama_parser/src/node.rs
@@ -42,12 +42,12 @@ impl<'a> Node<'a> {
         let result = match (|i: &mut _| Self::many(i, s)).parse_next(i) {
             Ok(result) => result,
             Err(err) => {
-                if let ErrMode::Backtrack(err) | ErrMode::Cut(err) = &err {
-                    if err.message.is_none() {
-                        *i = start;
-                        if let Some(mut span) = err.span.as_suffix_of(i) {
-                            opt(|i: &mut _| unexpected_tag(i, s)).parse_next(&mut span)?;
-                        }
+                if let ErrMode::Backtrack(err) | ErrMode::Cut(err) = &err
+                    && err.message.is_none()
+                {
+                    *i = start;
+                    if let Some(mut span) = err.span.as_suffix_of(i) {
+                        opt(|i: &mut _| unexpected_tag(i, s)).parse_next(&mut span)?;
                     }
                 }
                 return Err(err);
@@ -216,12 +216,12 @@ fn cut_node<'a, O>(
     move |i: &mut &'a str| {
         let start = *i;
         let result = inner.parse_next(i);
-        if let Err(ErrMode::Cut(err) | ErrMode::Backtrack(err)) = &result {
-            if err.message.is_none() {
-                *i = start;
-                if let Some(mut span) = err.span.as_suffix_of(i) {
-                    opt(|i: &mut _| unexpected_raw_tag(kind, i)).parse_next(&mut span)?;
-                }
+        if let Err(ErrMode::Cut(err) | ErrMode::Backtrack(err)) = &result
+            && err.message.is_none()
+        {
+            *i = start;
+            if let Some(mut span) = err.span.as_suffix_of(i) {
+                opt(|i: &mut _| unexpected_raw_tag(kind, i)).parse_next(&mut span)?;
             }
         }
         result
@@ -414,14 +414,14 @@ impl<'a> CondTest<'a> {
             ws(|i: &mut _| {
                 let start = *i;
                 let mut expr = Expr::parse(i, s.level, false)?;
-                if let Expr::BinOp(v) = &mut expr.inner {
-                    if matches!(v.rhs.inner, Expr::Var("set" | "let")) {
-                        let _level_guard = s.level.nest(i)?;
-                        *i = v.rhs.span.as_suffix_of(start).unwrap();
-                        let start_span = Span::from(*i);
-                        let new_right = Self::parse_cond(i, s)?;
-                        v.rhs.inner = Expr::LetCond(Box::new(WithSpan::new(new_right, start_span)));
-                    }
+                if let Expr::BinOp(v) = &mut expr.inner
+                    && matches!(v.rhs.inner, Expr::Var("set" | "let"))
+                {
+                    let _level_guard = s.level.nest(i)?;
+                    *i = v.rhs.span.as_suffix_of(start).unwrap();
+                    let start_span = Span::from(*i);
+                    let new_right = Self::parse_cond(i, s)?;
+                    v.rhs.inner = Expr::LetCond(Box::new(WithSpan::new(new_right, start_span)));
                 }
                 Ok(expr)
             }),
diff --git a/askama_parser/src/target.rs b/askama_parser/src/target.rs
index 6b999e09..22c0f670 100644
--- a/askama_parser/src/target.rs
+++ b/askama_parser/src/target.rs
@@ -165,10 +165,10 @@ impl<'a> Target<'a> {
                     *i,
                 );
             }
-            if let Target::Rest(ref s) = rest.0 {
-                if s.inner.is_some() {
-                    return cut_error!("`@ ..` cannot be used in struct", s.span);
-                }
+            if let Target::Rest(ref s) = rest.0
+                && s.inner.is_some()
+            {
+                return cut_error!("`@ ..` cannot be used in struct", s.span);
             }
             return Ok((rest.1, rest.0));
         }